Zokyo Gas Savings
  • โ›ฝZokyo Gas Savings
  • ๐Ÿ“šTutorials
    • โœ”๏ธGas Saving Technique 1: Unchecked Arithmetic
    • โ›“๏ธGas Saving Technique 2: Immutable Variable
    • โœจGas Saving Technique 3: Double star ** inefficiency
    • ๐Ÿ’ฐGas Saving Technique 4: Cache Array Length
    • โฌ…๏ธGas Saving Technique 5: ++i costs less gas compared to i++
    • โš–๏ธGas Saving Technique 6: NOT operator ! cheaper than boolean FALSE
    • ๐ŸชกGas Saving Technique 7: Using Short Reason Strings
    • ๐ŸชตGas Saving Technique 8: Use Custom Errors instead of Revert Strings to save Gas
    • โœ’๏ธGas Saving Technique 9: Use Custom Errors instead of Revert Strings to save Gas
    • ๐Ÿ‘พGas Saving Technique 10: Calldata cheaper than memory
    • โ›”Gas Saving Technique 11: > 0 is less efficient than != 0 for unsigned integers
    • โž—Gas Saving Technique 12: SafeMath no longer needed
    • ๐Ÿ˜ฎGas Saving Technique 13: variables default to 0
    • ๐ŸงฑGas Saving Technique 14: struct layout/ variable packing
    • ๐Ÿ“žGas Saving Technique 15: Cache External Call
    • โœ๏ธGas Saving Technique 16: Early Validation before external call
    • ๐Ÿ˜ŽGas Saving Technique 17: Donโ€™t cache value that is used once
    • ๐Ÿ˜งGas Saving Technique 18: Redundant code
    • โœ…Gas Saving Technique 19: Early Validation before external call
    • โ›๏ธGas Saving Technique 20: Storage vs Memory read optimizations
    • โœ’๏ธGas Saving Technique 21: Unneeded If statements
    • ๐ŸŒ—Gas Saving Technique 22: >= is cheaper than >
    • ๐ŸŽ’Gas Saving Technique 23: Public to private constants
    • โน๏ธGas Saving Technique 24: Make unchanged variables constant/immutable
    • โฑ๏ธGas Saving Techniques 25: Redundant Access Control Checks
    • โžก๏ธGas Saving Technique 26: Shift Right instead of Dividing by 2
    • ๐ŸชƒGas Saving Tutorial 27: Efficient Boolean Comparison
    • ๐ŸคGas Saving Technique 28: && operator uses more gas
    • ๐Ÿ‘“Gas Saving Technique 29: x = x + y is cheaper than x += y
    • ๐Ÿ‘‚Gas Saving Technique 30: Using 1 and 2 rather than 0 and 1 saves gas
    • โšฝGas Saving Technique 31: Optimize Storage by Avoiding Booleans
    • ๐Ÿ”™Gas Saving Technique 32: Optimal Use of Named Return Variables in Solidity
    • ๐Ÿ›ข๏ธGas Saving Technique 33: Making Functions Payable for Optimized Gas Costs
    • โœ๏ธGas Saving Technique 34: Optimizing Storage References in Smart Contracts
    • โ›ฐ๏ธGas Saving Technique 35: Usage of uints/ints smaller than 32 bytes (256 bits) incurs overhead
    • ๐ŸŒช๏ธGas Saving Technique 36: Inlining Single Use Internal Functions for Savings
    • โ˜„๏ธGas Saving Technique 37: Switching from Public to External Functions for Savings
    • ๐ŸŽ†Gas Saving Technique 38: Upgrading Solidity Compiler to Improve Gas Efficiency and Security
    • ๐Ÿ•ถ๏ธGas Saving Technique 39: Avoiding Duplicated Code for Gas Savings
    • ๐Ÿ˜„Gas Saving Technique 40: Removal of Unused Internal Functions for Gas Savings
    • ๐Ÿ–‹๏ธGas Saving Tutorial 41: In-lining Single Use Modifiers For Gas Saving
    • โ›๏ธGas Saving Technique 42: `require` vs`assert`
Powered by GitBook
On this page
  1. Tutorials

Gas Saving Technique 34: Optimizing Storage References in Smart Contracts

PreviousGas Saving Technique 33: Making Functions Payable for Optimized Gas CostsNextGas Saving Technique 35: Usage of uints/ints smaller than 32 bytes (256 bits) incurs overhead

Last updated 1 year ago

In Solidity, every read operation from storage costs gas. Repeatedly accessing the same storage location can quickly rack up costs, especially within loops or large functions. By reusing storage references, developers can reduce these costs and improve the efficiency of their smart contracts.


Concept:

  1. Storage Access Costs: Each time data is fetched from storage, it costs gas. This is because storage on the Ethereum blockchain is expensive due to its persistent nature.

  2. Reusing Storage References: By fetching data once and saving its reference, you can reduce subsequent gas costs. This is especially useful for arrays or mappings where specific elements are accessed multiple times.


Examples & Recommendations:

1. NFTVault.showPosition(): Problem: Repeatedly calling positions[_nftIndex] in a function. Solution: Save its reference and use it.

Before Optimization:

solidityCopy codeuint256 debtPrincipal = positions[_nftIndex].debtPrincipal;
uint256 liquidatedAt = positions[_nftIndex].liquidatedAt;
//... other references to positions[_nftIndex] ...

After Optimization:

solidityCopy codePosition storage _position = positions[_nftIndex];
uint256 debtPrincipal = _position.debtPrincipal;
uint256 liquidatedAt = _position.liquidatedAt;
//... other references using _position ...

2. StakedCitadelVester.claimableBalance(): Problem: Repeatedly calling vesting[recipient] in a function. Solution: Save its reference and use it.

Before Optimization:

solidityCopy codeuint256 locked = vesting[recipient].lockedAmounts;
uint256 claimed = vesting[recipient].claimedAmounts;
//... other references to vesting[recipient] ...

After Optimization:

solidityCopy codeVestingParams storage _vestingParams = vesting[recipient];
uint256 locked = _vestingParams.lockedAmounts;
uint256 claimed = _vestingParams.claimedAmounts;
//... other references using _vestingParams ...

Step-by-Step Guide for Implementing the Storage Reference Optimization:

  1. Identification: Review your contract functions, especially ones that have multiple references to a specific element in an array or mapping.

  2. Modification: At the start of the function, fetch the storage reference once and store it in a local storage-typed variable.

  3. Refactoring: Replace all subsequent accesses with the local storage-typed variable.

  4. Testing: Thoroughly test the contract after refactoring to ensure the logic remains intact and observe the gas savings.


Benefits:

  1. Gas Savings: By reducing repeated storage accesses, you minimize the associated gas costs.

  2. Readable Code: Code can be more readable with a well-named storage reference variable, making it clear what data is being used.


Conclusion: By understanding the underlying costs associated with storage access and leveraging storage references efficiently, developers can produce more optimized smart contracts. This approach both minimizes gas costs and can enhance code clarity.

๐Ÿ“š
โœ๏ธ
Book an audit with Zokyo