Gas optimization with storage in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a storage variable for an unsigned integer.

Blockchain / Solidity

uint256 [1];

Drag options to blanks, or click blank then click option'

Amemory

Bstorage

Ctemp

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'memory' or 'storage' as variable names.

Leaving the variable name blank.

The variable name should be count. memory and storage are data location keywords, not variable names.

2fill in blank

medium

Complete the code to declare a fixed-size array in storage.

Blockchain / Solidity

uint256[[1]] numbers;

Drag options to blanks, or click blank then click option'

Alength

B5

Ccount

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names instead of a number for array size.

Leaving the size blank.

The array size must be a number literal like 5. Variable names like size or length are not valid here.

3fill in blank

hard

Fix the error in the function to reduce gas by using a local variable for storage reads.

Blockchain / Solidity

function getSum() public view returns (uint256) {
    uint256 [1] = a + b + c;
    return sum;
}

Drag options to blanks, or click blank then click option'

Asum

Btotal

Cresult

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different variable name than the return statement.

Not using a local variable at all.

The local variable should be named sum to match the return statement and reduce repeated storage reads.

4fill in blank

hard

Fill both blanks to optimize storage writes by caching in a local variable.

Blockchain / Solidity

function increment() public {
    uint256 [1] = [2];
    [2] = [1] + 1;
}

Drag options to blanks, or click blank then click option'

Atemp

Bcounter

Ccount

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Writing directly to storage multiple times.

Using the same name for both variables.

Cache the storage variable counter in a local variable temp, then update counter after incrementing.

5fill in blank

hard

Fill all three blanks to create a mapping and update it efficiently.

Blockchain / Solidity

mapping(address => uint256) public [1];

function updateBalance(address user, uint256 amount) public {
    uint256 [2] = [3][user];
    [3][user] = [2] + amount;
}

Drag options to blanks, or click blank then click option'

Abalances

BcurrentBalance

Cbalance

Dtemp

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent variable names.

Not caching the balance before updating.

The mapping is named balances. Cache the user's balance in currentBalance and update balances[user] after adding amount.

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