Gas Optimizations #125
Labels
bug
Something isn't working
G (Gas Optimization)
sponsor confirmed
Sponsor agrees this is a problem and intends to fix it (OK to use w/ "disagree with severity")
Comments
mundhrakeshav
added
the
sponsor confirmed
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Overview
Table of Contents:
memorykeyword whenstorageshould be used>=is cheaper than>(and<=cheaper than<)require()statements that use&&saves gas<array>.lengthshould not be looked up in every loop of afor-loop++icosts less gas compared toi++ori += 1(same for--ivsi--ori -= 1)payable1. Use of the
memorykeyword whenstorageshould be usedHere, the
storagekeyword should be used instead ofmemory:File: Twav.sol 35: function _getTwav() internal view returns(uint256 _twav){ 36: if (twavObservations[TWAV_BLOCK_NUMBERS - 1].timestamp != 0) { 37: uint8 _index = ((twavObservationsIndex + TWAV_BLOCK_NUMBERS) - 1) % TWAV_BLOCK_NUMBERS; - 38: TwavObservation memory _twavObservationCurrent = twavObservations[(_index)]; + 38: TwavObservation storage _twavObservationCurrent = twavObservations[(_index)]; - 39: TwavObservation memory _twavObservationPrev = twavObservations[(_index + 1) % TWAV_BLOCK_NUMBERS]; + 39: TwavObservation storage _twavObservationPrev = twavObservations[(_index + 1) % TWAV_BLOCK_NUMBERS]; 40: _twav = (_twavObservationCurrent.cumulativeValuation - _twavObservationPrev.cumulativeValuation) / (_twavObservationCurrent.timestamp - _twavObservationPrev.timestamp); 41: } 42: }2. Unchecking arithmetics operations that can't underflow/overflow
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
uncheckedblock: https://docs.soliditylang.org/en/v0.8.10/control-structures.html#checked-or-unchecked-arithmeticConsider wrapping with an
uncheckedblock here:311: if (_totalSupply >= _initialTokenSupply) { ... 313: } else { ... - 319: _purchaseReturn = _initialTokenSupply - _totalSupply; + 319: unchecked { _purchaseReturn = _initialTokenSupply - _totalSupply; }373: if(_totalSupply > _initialTokenSupply) { ... - 378: uint256 _tokensPrimaryCurve = _totalSupply - _initialTokenSupply; + 378: unchecked { uint256 _tokensPrimaryCurve = _totalSupply - _initialTokenSupply; }414: if (_buyoutBid > _currentValuation) { - 415: safeTransferETH(payable(msg.sender), (_buyoutBid - _currentValuation)); + 415: unchecked { safeTransferETH(payable(msg.sender), (_buyoutBid - _currentValuation) });3. Caching storage values in memory
The code can be optimized by minimising the number of SLOADs.
SLOADs are expensive (100 gas after the 1st one) compared to MLOADs/MSTOREs (3 gas each). Storage values read multiple times should instead be cached in memory the first time (costing 1 SLOAD) and then read from this cache to avoid multiple SLOADs.
See the
@audittags for details about the multiple SLOADs where a cached value should be used instead ofSLOAD 2and above:twavObservationsIndex: https://github.com/code-423n4/2022-06-nibbl/blob/8c3dbd6adf350f35c58b31723d42117765644110/contracts/Twav/Twav.sol#L27-L29secondaryReserveBalance: https://github.com/code-423n4/2022-06-nibbl/blob/8c3dbd6adf350f35c58b31723d42117765644110/contracts/NibblVault.sol#L222-L226secondaryReserveBalance: https://github.com/code-423n4/2022-06-nibbl/blob/8c3dbd6adf350f35c58b31723d42117765644110/contracts/NibblVault.sol#L314-L320primaryReserveBalance: https://github.com/code-423n4/2022-06-nibbl/blob/8c3dbd6adf350f35c58b31723d42117765644110/contracts/NibblVault.sol#L379-L380basketUpdateTime: https://github.com/code-423n4/2022-06-nibbl/blob/8c3dbd6adf350f35c58b31723d42117765644110/contracts/NibblVaultFactory.sol#L107feeToUpdateTime: https://github.com/code-423n4/2022-06-nibbl/blob/8c3dbd6adf350f35c58b31723d42117765644110/contracts/NibblVaultFactory.sol#L131vaultUpdateTime: https://github.com/code-423n4/2022-06-nibbl/blob/8c3dbd6adf350f35c58b31723d42117765644110/contracts/NibblVaultFactory.sol#L1664. Cheap Contract Deployment Through Clones
See
@audittag:There's a way to save a significant amount of gas on deployment using Clones: https://www.youtube.com/watch?v=3Mw-pMmJ7TA .
This is a solution that was adopted, as an example, by Porter Finance. They realized that deploying using clones was 10x cheaper:
Consider applying a similar pattern, here with a
cloneDeterministicmethod to mimic the currentcreate25. Reduce the size of error messages (Long revert Strings)
Shortening revert strings to fit in 32 bytes will decrease deployment time gas and will decrease runtime gas when the revert condition is met.
Revert strings that are longer than 32 bytes require at least one additional mstore, along with additional overhead for computing memory offset, etc.
Revert strings > 32 bytes:
Consider shortening the revert strings to fit in 32 bytes.
6. SafeMath is not needed when using Solidity version 0.8+
Solidity version 0.8+ already implements overflow and underflow checks by default.
Using the SafeMath library from OpenZeppelin (which is more gas expensive than the 0.8+ overflow checks) is therefore redundant.
Consider using the built-in checks instead of SafeMath and remove SafeMath here:
7. Duplicated conditions should be refactored to a modifier or function to save deployment costs
8. Internal/Private functions only called once can be inlined to save gas
Not inlining costs 20 to 40 gas because of two extra
JUMPinstructions and additional stack operations needed for function calls.Affected code:
NibblVault.sol#getMaxSecondaryCurveBalance()9.
>=is cheaper than>(and<=cheaper than<)Strict inequalities (
>) are more expensive than non-strict ones (>=). This is due to some supplementary checks (ISZERO, 3 gas). This also holds true between<=and<.Consider replacing strict inequalities with non-strict ones to save some gas here:
10. Splitting
require()statements that use&&saves gasIf you're using the Optimizer at 200, instead of using the
&&operator in a single require statement to check multiple conditions, Consider using multiple require statements with 1 condition per require statement:Please, note that this might not hold true at a higher number of runs for the Optimizer (10k). However, it indeed is true at 200.
11. Using private rather than public for constants saves gas
If needed, the value can be read from the verified contract source code. Savings are due to the compiler not having to create non-payable getter functions for deployment calldata, and not adding another entry to the method ID table
12. Amounts should be checked for 0 before calling a transfer
Checking non-zero transfer values can avoid an expensive external call and save gas (especially in loops, like in
NibblVault.sol#withdrawMultipleERC20()).Consider adding a non-zero-value check here:
13.
<array>.lengthshould not be looked up in every loop of afor-loopReading array length at each iteration of the loop consumes more gas than necessary.
In the best case scenario (length read on a memory variable), caching the array length in the stack saves around 3 gas per iteration.
In the worst case scenario (external calls at each iteration), the amount of gas wasted can be massive.
Here, Consider storing the array's length in a variable before the for-loop, and use this new variable instead:
14.
++icosts less gas compared toi++ori += 1(same for--ivsi--ori -= 1)Pre-increments and pre-decrements are cheaper.
For a
uint256 ivariable, the following is true with the Optimizer enabled at 10k:Increment:
i += 1is the most expensive formi++costs 6 gas less thani += 1++icosts 5 gas less thani++(11 gas less thani += 1)Decrement:
i -= 1is the most expensive formi--costs 11 gas less thani -= 1--icosts 5 gas less thani--(16 gas less thani -= 1)Note that post-increments (or post-decrements) return the old value before incrementing or decrementing, hence the name post-increment:
However, pre-increments (or pre-decrements) return the new value:
In the pre-increment case, the compiler has to create a temporary variable (when used) for returning
1instead of2.Affected code:
Consider using pre-increments and pre-decrements where they are relevant (meaning: not where post-increments/decrements logic are relevant).
15. Increments/decrements can be unchecked in for-loops
In Solidity 0.8+, there's a default overflow check on unsigned integers. It's possible to uncheck this in for-loops and save some gas at each iteration, but at the cost of some code readability, as this uncheck cannot be made inline.
ethereum/solidity#10695
Affected code:
The change would be:
The same can be applied with decrements (which should use
breakwheni == 0).The risk of overflow is non-existant for
uint256here.16. Public functions to external
An external call cost is less expensive than one of a public function.
The following functions could be set external to save gas and improve code quality (extracted from Slither).
17. It costs more gas to initialize variables with their default value than letting the default value be applied
If a variable is not set/initialized, it is assumed to have the default value (
0foruint,falseforbool,address(0)for address...). Explicitly initializing it with its default value is an anti-pattern and wastes gas.As an example:
for (uint256 i = 0; i < numIterations; ++i) {should be replaced withfor (uint256 i; i < numIterations; ++i) {Affected code:
Consider removing explicit initializations for default values.
18. Use Custom Errors instead of Revert Strings to save Gas
Solidity 0.8.4 introduced custom errors. They are more gas efficient than revert strings, when it comes to deploy cost as well as runtime cost when the revert condition is met. Use custom errors instead of revert strings for gas savings.
Custom errors from Solidity 0.8.4 are cheaper than revert strings (cheaper deployment cost and runtime cost when the revert condition is met)
Source: https://blog.soliditylang.org/2021/04/21/custom-errors/:
Custom errors are defined using the
errorstatement, which can be used inside and outside of contracts (including interfaces and libraries).Consider replacing all revert strings with custom errors in the solution.
19. Functions guaranteed to revert when called by normal users can be marked
payableIf a function modifier such as
onlyOwneris used, the function will revert if a normal user tries to pay the function. Marking the function aspayablewill lower the gas cost for legitimate callers because the compiler will not include checks for whether a payment was provided.The text was updated successfully, but these errors were encountered: