Gas optimization with storage in Blockchain / Solidity

Introduction

Storing data on blockchain costs gas, which is like paying for space. Optimizing storage helps save money and makes your smart contract efficient.

When you want to save money on deploying or running smart contracts.

When your contract needs to store many pieces of data but you want to reduce gas fees.

When you want your contract to run faster by reducing storage operations.

When you want to avoid unnecessary writes to blockchain storage.

When designing contracts that handle user data or state changes frequently.

Syntax

Blockchain / Solidity

// Example: Using smaller data types and packing variables
contract Example {
    uint128 smallNumber;
    bool flag;
    // Both variables fit in one storage slot, saving gas
}

Use smaller data types like uint8, uint16 instead of uint256 when possible.

Group variables of the same type together to pack them into fewer storage slots.

Examples

Using uint8 instead of uint256 saves storage space and gas.

Blockchain / Solidity

// Using smaller data types
uint8 age = 30;
uint8 score = 100;

Variables packed into one storage slot reduce gas cost.

Blockchain / Solidity

// Packing variables
contract Packed {
    uint128 a;
    uint128 b;
    bool c;
}

Only update storage if the value changes to save gas.

Blockchain / Solidity

// Avoid unnecessary storage writes
function update(uint256 newValue) public {
    if (storedValue != newValue) {
        storedValue = newValue;
    }
}

Sample Program

This contract uses smaller data types and updates storage only when needed to save gas.

Blockchain / Solidity

pragma solidity ^0.8.20;

contract GasOptimized {
    // Using smaller data types and packing
    uint128 public smallNumber;
    bool public flag;

    constructor(uint128 _num, bool _flag) {
        smallNumber = _num;
        flag = _flag;
    }

    // Update only if value changes
    function updateNumber(uint128 _num) public {
        if (smallNumber != _num) {
            smallNumber = _num;
        }
    }
}

Important Notes

Reading from storage is cheaper than writing, so minimize writes.

Use constants and immutable variables when possible to reduce storage.

Consider using events to log data instead of storing it if you don't need to read it on-chain.

Summary

Storing less data or packing variables saves gas.

Only write to storage when necessary.

Use smaller data types and group variables smartly.

Practice

1. Why is it important to optimize storage usage in blockchain smart contracts?

easy

A. Because storage is unlimited and free to use

B. Because storage variables are faster to access than memory variables

C. Because storage operations consume more gas, increasing transaction costs

D. Because storage variables do not affect gas costs

Solution

1. Step 1: Understand gas cost of storage

   Storage operations in blockchain smart contracts consume significant gas compared to memory or stack operations.

2. Step 2: Impact on transaction cost

   Higher gas consumption means higher transaction fees for users interacting with the contract.

3. Final Answer:

   Because storage operations consume more gas, increasing transaction costs -> Option C

4. Quick Check:

   Storage gas cost = higher fees [OK]

Hint: Remember: storage costs gas, so optimize to save money [OK]

Common Mistakes:

• Thinking storage is free
• Confusing storage with memory gas costs
• Assuming storage is faster than memory

2. Which of the following Solidity declarations helps reduce gas by optimizing storage usage?

easy

A. uint8 public smallNumber; uint8 public anotherSmallNumber;

B. constant uint256 public MAX_VALUE = 1000;

C. uint256 public data;

D. string public name;

Solution

1. Step 1: Identify constant usage

   Declaring variables as constant stores their value in bytecode, not storage, saving gas.

2. Step 2: Compare with other declarations

   Other options use storage variables which consume gas on read/write, unlike constants.

3. Final Answer:

   constant uint256 public MAX_VALUE = 1000; -> Option B

4. Quick Check:

   Constants reduce storage gas [OK]

Hint: Use constants to save storage gas costs [OK]

Common Mistakes:

• Assuming all variables cost the same gas
• Not knowing constants are stored differently
• Ignoring variable size impact

3. Consider this Solidity snippet:

contract Test {
    uint8 a = 1;
    uint8 b = 2;
    uint16 c = 3;
}

How many storage slots does this contract use?

medium

A. 1 storage slot

B. 2 storage slots

C. 3 storage slots

D. 4 storage slots

Solution

1. Step 1: Understand storage slot packing

   Solidity packs variables into 32-byte slots if their sizes fit together.

2. Step 2: Calculate combined size

   uint8 + uint8 + uint16 = 1 + 1 + 2 = 4 bytes, which fits into one 32-byte slot.

3. Final Answer:

   1 storage slot -> Option A

4. Quick Check:

   Small types packed = 1 slot [OK]

Hint: Pack small variables to fit one storage slot [OK]

Common Mistakes:

• Assuming each variable uses one slot
• Ignoring variable size packing
• Confusing bytes with slots

4. Identify the gas optimization mistake in this Solidity code:

contract Example {
    uint256 public count;
    function increment() public {
        count = count + 1;
    }
}

medium

A. Using uint256 instead of uint8 for small counters

B. Not marking count as immutable

C. Using count = count + 1; instead of ++count;

D. Not using constant for count

Solution

1. Step 1: Analyze variable type choice

   Using uint256 for a small counter wastes storage space and gas.

2. Step 2: Suggest smaller type

   Using uint8 or smaller type packs better and reduces gas cost.

3. Final Answer:

   Using uint256 instead of uint8 for small counters -> Option A

4. Quick Check:

   Smaller types save gas [OK]

Hint: Use smallest uint type needed for counters [OK]

Common Mistakes:

• Thinking increment syntax affects gas
• Confusing constant and immutable usage
• Ignoring variable size impact

5. You want to store multiple boolean flags in a contract efficiently. Which approach optimizes gas usage best?

hard

A. Use separate bool variables for each flag

B. Use multiple uint256 variables for each flag

C. Use an array of bool variables

D. Use a single uint8 variable and bitwise operations to store flags

Solution

1. Step 1: Understand storage cost of booleans

   Each bool uses a full storage slot if declared separately, wasting gas.

2. Step 2: Use bit packing with uint8

   Storing multiple flags as bits in a single uint8 packs them efficiently, reducing storage slots and gas.

3. Step 3: Compare other options

   Arrays and multiple uint256 variables consume more storage and gas.

4. Final Answer:

   Use a single uint8 variable and bitwise operations to store flags -> Option D

5. Quick Check:

   Bit packing booleans saves gas [OK]

Hint: Pack booleans into bits using uint types [OK]

Common Mistakes:

• Using separate bools wastes storage
• Assuming arrays are cheaper
• Ignoring bitwise operations benefits