Gas optimization with storage in Blockchain / Solidity - Mini Project: Build & Apply

Gas Optimization with Storage in Solidity

📖 Scenario: You are building a simple smart contract on the Ethereum blockchain that stores user balances. Since storing data on the blockchain costs gas (real money), you want to optimize how you store and update these balances to save gas fees.

🎯 Goal: Create a Solidity contract that stores user balances efficiently by minimizing storage writes, and then display the final balances.

📋 What You'll Learn

Create a mapping called balances to store user addresses and their uint balances.

Create a uint variable called increment to hold the amount to add to each balance.

Write a function that loops through a list of addresses and adds increment to each balance using a local variable to minimize storage writes.

Print the final balances of all users.

💡 Why This Matters

🌍 Real World

Smart contracts on blockchains like Ethereum charge gas fees for storage operations. Optimizing how you read and write data can save users money and make your contract more efficient.

💼 Career

Blockchain developers must write gas-efficient code to build scalable and cost-effective decentralized applications.

1

DATA SETUP: Create the balances mapping

Create a public mapping called balances that maps address to uint. Initialize balances for three addresses: 0x1111111111111111111111111111111111111111 with 100, 0x2222222222222222222222222222222222222222 with 200, and 0x3333333333333333333333333333333333333333 with 300.

Blockchain / Solidity

// Your code here

Hint

Use mapping(address => uint) public balances; and set initial values in the constructor.

2

CONFIGURATION: Add the increment variable

Add a public uint variable called increment and set it to 50.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract GasOptimization {
    mapping(address => uint) public balances;
    
    // Add increment variable here
    
    constructor() {
        balances[0x1111111111111111111111111111111111111111] = 100;
        balances[0x2222222222222222222222222222222222222222] = 200;
        balances[0x3333333333333333333333333333333333333333] = 300;
    }
}

Hint

Declare uint public increment = 50; inside the contract but outside the constructor.

3

CORE LOGIC: Optimize balance updates using a local variable

Write a public function called addIncrement that takes an array of addresses called users. For each user, load their balance into a local uint variable, add increment to it, then update the mapping once with the new balance.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract GasOptimization {
    mapping(address => uint) public balances;
    uint public increment = 50;

    constructor() {
        balances[0x1111111111111111111111111111111111111111] = 100;
        balances[0x2222222222222222222222222222222222222222] = 200;
        balances[0x3333333333333333333333333333333333333333] = 300;
    }

    // Write addIncrement function below
    
}

Hint

Use a for loop over users, read balance into currentBalance, add increment, then write back.

4

OUTPUT: Display final balances after increment

Write a public view function called getBalances that takes an array of addresses called users and returns an array of uints with their balances. Then, after calling addIncrement with the three addresses, call getBalances with the same addresses and print the returned balances.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract GasOptimization {
    mapping(address => uint) public balances;
    uint public increment = 50;

    constructor() {
        balances[0x1111111111111111111111111111111111111111] = 100;
        balances[0x2222222222222222222222222222222222222222] = 200;
        balances[0x3333333333333333333333333333333333333333] = 300;
    }

    function addIncrement(address[] memory users) public {
        for (uint i = 0; i < users.length; i++) {
            uint currentBalance = balances[users[i]];
            currentBalance += increment;
            balances[users[i]] = currentBalance;
        }
    }

    // Write getBalances function and example usage below
}

Hint

Create a getBalances function that returns an array of balances for given addresses.

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