Solidity-gas-optimizations-tips

KO | EN

gitlite — search

#javascript #hacktoberfest #react #typescript #machine-learning #rust #deep-learning #linux #macos #java #windows #cli #awesome-list #ios

Solidity-gas-optimizations-tips

(★ 32)

No description available.

Solidity-gas-optimizations-tips Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

## Gas optimizations tips found in open source audits 💡

⬜   `REQUIRE()/REVERT()` STRINGS LONGER THAN 32 BYTES COST EXTRA GAS
```python
def utf8len(s):
    return len(s.encode('utf-8'))

utf8len('FCash to redeem must be an index component')
```

---

⬜  `PRIVATE` FUNCTIONS NOT CALLED BY THE CONTRACT SHOULD BE REMOVED TO SAVE DEPLOYMENT GAS

---

⬜ `PUBLIC` FUNCTIONS NOT CALLED BY THE CONTRACT SHOULD BE DECLARED `EXTERNAL` INSTEAD

---

⬜   ADDING `UNCHEKED` DIRECTIVE CAN SAVE GAS
> For arithmetic operations that will not owerflow/underflow anyone, use unchecked, this will help save gas from unnecessary > owerflow/underflow checks in solidity version starting with 0.8

---

⬜   `array.length` SHOULD NOT BE LOOKED UP IN EVERY LOOP OF FOR-LOOP
> Reading array length at each iteration of the loop takes 6 gas

---

⬜   `++i` COSTS LESS GAS COMPARED TO *i++* OR *i += 1* (SAME FOR `--i` VS `i--` OR `i -= 1`)
    Increment:
- `i += 1` is the most expensive form
- `i++` costs 6 gas less than `i += 1`
- `++i` costs 5 gas less than `i++` (11 gas less than `i += 1`)
    Decrement:
- `i -= 1` is the most expensive form
- `i--` costs 11 gas less than `i -= 1`
- `-i` costs 5 gas less than `i--` (16 gas less than `i -= 1`)
---

⬜   USE `address(0)` INSTEAD OF `0x00000000000000000000000000000000000000000000000000000000000000`

---

⬜   CHECK IF `AMOUNT > 0` BEFORE TOKEN TRANSFER CAN SAVE GAS
> It worth cheking the `AMOUNT ≠ 0`, before the transfer can create an external call and spend unnecessary gas cost

---

⬜   `> 0` CAN BE REPLACED WITH `!= 0` FOR GAS OPTIMIZATION
> `!= 0` is a cheaper operation compared to `> 0`, when dealing with uint

---

⬜   CONSIDER MAKING SOME CONSTANTS AS NON-PUBLIC TO SAVE GAS
> Switching from public to private/internal can save gas when the constant is not used outside od its contract
---

⬜ UNUSED NAMED RETURN VARIABLES - 3 gas per instance

---

⬜  CONSTRUCTOR PARAMETERS SHOULD BE AVOIDED WHEN POSSIBLE
> Constructor parameters are expensive. The contract deployment will be cheaper in gas if they are hard coded instead of using constructor parameters

---

⬜  CALLDATA INSTEAD OF MEMORY FOR READ-ONLY FUNCTION PARAMETERS
> If a reference type function parameter is read-only, it is cheaper in gas to use calldata instead of memory. (Calldata is a non-modifiable, non-persistent area where function arguments are stored, and behaves mostly like memory)
---

⬜  CACHING STORAGE VARIABLES IN MEMORY TO SAVE GAS
> Anytime you are reading from storage more than once, it is cheaper in gas cost to cache the variable in memory: a SLOAD cost 100gas, while MLOAD and MSTORE cost 3 gas.
---

⬜  `uint256` instead of `uint8`
> The EVM works with 256bit/32byte words. Every operation is based on these base units. If the data used is smaller, further operation are needed to downscale from 256 bits to 8 bits.
---

⬜  `X = X + Y` IS CHEAPER THAN `X += Y` (Same for `X = X - Y` is cheaper than `X -= Y`)
> `X += Y` costs 3,more gas than `X = X + Y`.
---

⬜ UNNECESSARY COMPUTATION
> Gas can be saved by avoiding using local variables when they are not necessary.
---

⬜ AVOID A SLOAD OPTIMISTICALLY - 2.1k gas saved

---

⬜ CHECK msg.value FIRST - 1 gas per instance
> Reading msg.value costs 2 gas, while reading from memory costs 3, this will save 1 gas with no downside
> `if (weth == asset && msg.value > 0)` change to `if (msg.value > 0 && weth == asset)`
---

⬜ MIXING RETURN AND NAMED RETURNS
> Using both named returns and a return statement isn't necessary. Removing unused named return variables can reduce gas usage (MSTOREs/MLOADs) and improve code clarity. 
> To save gas and improve code quality: consider using only one of those.
---

⬜ INLINE A MODIFIER THAT’S ONLY USED ONCE
> If modifier is only used once in this contract, it should get inlined to save gas
---

⬜  USE abi.encodePacked() not abi.encode()

---

⬜ USE NESTED IF AND, AVOID MULTIPLE CHECK COMBINATIONS 
> Using `nested if` cheaper then using `&&` multiple check combinations. There are more advantages, such as easier to read code and better coverage reports.

---

⬜ UNINITIALIZED VARIABLES ARE ASSIGNED WITH THE TYPES DEFAULT VALUE
> Explicitly initializing a variable with it's default value costs unnecesary gas

---

⬜ USE CUSTOM ERRORS INSTEAD OF REVERT STRINGS TO SAVE GAS
> Custom errors from Solidity 0.8.4 are cheaper than revert strings (cheaper deployment cost and runtime cost when the revert condition is met) while providing the same amount of information

---

⬜ STATE VARIABLES ONLY SET IN THE CONSTRUCTOR SHOULD BE DECLARED `IMMUTABLE`
> Avoids a `Gsset` (20000 gas) in the constructor, and replaces each `Gwarmacces` (100 gas) with a `PUSH32` (3 gas).

---

⬜ `INTERNAL` FUNCTIONS ONLY CALLED ONCE CAN BE INLINED TO SAVE GAS
> Not inlining costs 20 to 40 gas because of two extra JUMP instructions and additional stack operations needed for function calls.

---
 
⬜ OPERATORS: AND/OR

> When having a require statement with 2 or more expressions needed, place the expression that cost less gas first.
For example:
- require ( A || B ): If a is true, Solidity compiler won’t check the next statement because it’s not needed.
- require ( A && B ): If a is false, Solidity compiler won’t check the next statement because it’s not needed.
In this examples, the best approach would be placing the cheapest expression as A.

---

⬜ Always try reverting transactions as early as possible when using require statements (most preferably before writing in storage). 
> In case a transaction revert occurs, the user will pay the gas up until the revert was executed (not afterwards).

---

⬜ USE `mapping` INSTEAD OF `array` (5000 gas saved per value)

> Mappings are usually less expensive than arrays, but you can’t iterate over them.
---

⬜  USE `require` INSTEAD OF `assert`

> Assert should NOT be used by other mean than testing purposes. (because when the assertion fails, gas is NOT refunded contrary to require)

---

⬜  Look for dead code (saves a variable amount of gas on deployment)

Sometimes, developers forget to remove useless code like:
```plain
require(a == 0)
if (a == 0) {
  return true;
} else {
  return false
}
```

---

⬜ STORING DATA IN `events` (up to 20 000 gas saved on function call)
> If you don’t need to access the data onchain in solidity, you can store it using events.
---

Solidity-gas-optimizations-tips

Solidity-gas-optimizations-tips Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Solidity-gas-optimizations-tips

Solidity-gas-optimizations-tips Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README