Gas Optimizations

Number	Issue	Instances
[G-01]	Setting the constructor to payable	5
[G-02]	Using delete statement can save gas	1
[G-03]	Functions guaranteed to revert when called by normal users can be marked payable	5
[G-04]	Use hardcode address instead address(this)	13
[G-05]	+= Costs More Gas Than = + For State Variables	14
[G-06]	Public Functions To External	5
[G-07]	Using unchecked blocks to save gas	30
[G-08]	Use assembly to emit events	20
[G-09]	Use assembly to validate msg.sender	7
[G-10]	Multiple address mappings can be combined into a single mapping of an address to a struct, where appropriate	1
[G-11]	Using storage instead of memory for structs/arrays saves gas	10
[G-12]	Usage of uints/ints smaller than 32 bytes (256 bits) incurs overhead	1
[G-13]	Internal/Private functions only called once can be inlined to save gas Gas saved: 20 * 20 = 400	2
[G-14]	Use assembly to write address storage values	3
[G-15]	.length should not be looked up in every loop of a for-loop	6
[G-16]	Using > 0 costs more gas than != 0 when used on a uint in a require() statement	5
[G-17]	Use custom errors rather than revert()/require() strings to save gas	2
[G-18]	Using private rather than public for constants, saves gas	3
[G-19]	Use assembly to check for address(0)	3
[G-20]	Don’t initialize variables with default value	9
[G-21]	Amounts should be checked for 0 before calling a transfer	3
[G-22]	abi.encode() is less efficient than abi.encodePacked()	3

[G-01] Setting the constructor to payable

Saves ~13 gas per instance.

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/utils/Ownable.sol#L14

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Staking.sol#L31

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L73

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Fees.sol#L19

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Beedle.sol#L11

[G-02] Using delete statement can save gas

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Staking.sol#L56

[G-03] Functions guaranteed to revert when called by normal users can be marked payable

If a function modifier or require such as onlyOwner/onlyX is used, the function will revert if a normal user tries to pay the function. Marking the function as payable will lower the gas cost for legitimate callers because the compiler will not include checks for whether a payment was provided.

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Beedle.sol#L36

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L84

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/utils/Ownable.sol#L19

[G-04] Use hardcode address instead address(this)

Instead of using address(this), it is more gas-efficient to pre-calculate and use the hardcoded address. Foundry’s script.sol and solmate’s LibRlp.sol contracts can help achieve this.

References:

https://book.getfoundry.sh/reference/forge-std/compute-create-address
https://twitter.com/transmissions11/status/1518507047943245824

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Staking.sol#L39

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Fees.sol#L28

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L154

[G-05] += Costs More Gas Than = + For State Variables

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L263

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Staking.sol#L41

[G-06] Public Functions To External

The following functions could be set external to save gas and improve code quality.
External call cost is less expensive than of public functions.

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Fees.sol#L26

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L292

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/utils/Ownable.sol#L19

[G-07] Using unchecked blocks to save gas

Solidity version 0.8+ comes with implicit overflow and underflow checks on unsigned integers. When an overflow or an underflow isn’t possible (as an example, when a comparison is made before the arithmetic operation), some gas can be saved by using an unchecked block.

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L120

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Staking.sol#L70

[G-08] Use assembly to emit events

We can use assembly to emit events efficiently by utilizing scratch space and the free memory pointer. This will allow us to potentially avoid memory expansion costs.

Note: In order to do this optimization safely, we will need to cache and restore the free memory pointer.

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L165

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/utils/Ownable.sol#L16

[G-09] Use assembly to validate msg.sender

We can use assembly to efficiently validate msg.sender for the didPay and uniswapV3SwapCallback functions with the least amount of opcodes necessary. Additionally, we can use xor() instead of iszero(eq()), saving 3 gas. We can also potentially save gas on the unhappy path by using scratch space to store the error selector, potentially avoiding memory expansion costs.

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/utils/Ownable.sol#L11

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L183

[G-10] Multiple address mappings can be combined into a single mapping of an address to a struct, where appropriate

We can combine multiple mappings below into structs. This will result in cheaper storage reads since multiple mappings are accessed in functions and those values are now occupying the same storage slot, meaning the slot will become warm after the first SLOAD. In addition, when writing to and reading from the struct values we will avoid a Gsset (20000 gas) and Gcoldsload (2100 gas) since multiple struct values are now occupying the same slot.

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Staking.sol#L19

[G-11] Using storage instead of memory for structs/arrays saves gas

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L117

[G-12] Usage of uints/ints smaller than 32 bytes (256 bits) incurs overhead

The EVM operates with 32 byte words. Therefore, if you declare state variables less than 32 bytes the EVM will need to perform extra operations to cast your value to the specified size.

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/interfaces/ISwapRouter.sol#L8

[G-13] Internal/Private functions only called once can be inlined to save gas Gas saved: 20 * 20 = 400

Not inlining costs 20 to 40 gas because of two extra JUMP instructions and additional stack operations needed for function calls.

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Beedle.sol#L15-L18

[G-14] Use assembly to write address storage values

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L100-L102

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/utils/Ownable.sol#L14-L17

Recommendation Code

[G‑15] .length should not be looked up in every loop of a for-loop

The overheads outlined below are PER LOOP, excluding the first loop

storage arrays incur a Gwarmaccess (100 gas)
memory arrays use MLOAD (3 gas)
calldata arrays use CALLDATALOAD (3 gas)

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L233

[G‑16] Using > 0 costs more gas than != 0 when used on a uint in a require() statement

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Staking.sol#L63

[G‑17] Use custom errors rather than revert()/require() strings to save gas

Custom errors are available from solidity version 0.8.4.

Custom errors save ~50 gas each time they’re hit by avoiding having to allocate and store the revert string. Not defining the strings also save deployment gas.

src/Fees.sol
https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Fees.sol#L27

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/utils/Ownable.sol#L11

[G‑18] Using private rather than public for constants, saves gas

If needed, the values can be read from the verified contract source code, or if there are multiple values there can be a single getter function that returns a tuple of the values of all currently-public constants. Saves 3406-3606 gas in deployment gas due to the compiler not having to create non-payable getter functions for deployment calldata, not having to store the bytes of the value outside of where it’s used, and not adding another entry to the method ID table.

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Fees.sol#L16

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L59

[G-19] Use assembly to check for address(0)

Saves 6 gas per instance

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L167

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/utils/Ownable.sol#L16

[G-20] Don’t initialize variables with default value

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L233

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Staking.sol#L14

[G-21] Amounts should be checked for 0 before calling a transfer

Checking non-zero transfer values can avoid an expensive external call and save gas.
While this is done at some places, it’s not consistently done in the solution.
I suggest adding a non-zero-value check here:

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Beedle.sol#L19

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Staking.sol#L39

[G-22] abi.encode() is less efficient than abi.encodePacked()

Consider changing it if possible.
There are 4 instances of this issue:

https://github.com/Cyfrin/2023-07-beedle/blob/main/src/Lender.sol#L113