Gas optimization with storage in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Gas optimization with storage

Start Transaction

↓

Check Storage Usage

↓

Is Storage Write Needed?

No→Skip Write

Yes↓

Write to Storage (Expensive)

↓

Use Memory/Stack if Possible (Cheaper)

↓

Minimize Storage Writes

↓

End Transaction

This flow shows how to decide when to write to storage to save gas by minimizing expensive storage operations.

Execution Sample

Blockchain / Solidity

uint256 storageVar;

function update() public {
  uint256 x = 5;
  uint256 y;
  y = x + 10; // memory operation
  storageVar = y; // storage write
}

This code updates a storage variable by first calculating in memory, then writing once to storage to save gas.

Execution Table

Step	Operation	Variable	Value	Gas Cost	Note
1	Initialize x	x	5	0	x is in memory, no gas cost
2	Declare y	y	0	0	y is uninitialized
3	Calculate y = x + 10	y	15	Low	Calculation in memory, cheap
4	Write y to storageVar	storageVar	15	High	Storage write is expensive
5	End function	-	-	0	Transaction ends

💡 Function ends after one storage write to minimize gas

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
x	5	5	5	5
y	0	15	15	15
storageVar	0	0	15	15

Key Moments - 2 Insights

Why do we calculate y in memory before writing to storageVar?

Calculating y in memory (Step 3) is cheaper than multiple storage writes. Writing once to storage (Step 4) saves gas by minimizing expensive storage operations.

What makes storage writes expensive compared to memory operations?

Storage writes (Step 4) cost more gas because they change blockchain state permanently, unlike memory calculations (Step 3) which are temporary and cheaper.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of y after Step 3?

A 15

B 5

C 0

D 10

💡 Hint

Check the 'Value' column for y at Step 3 in the execution table

At which step does the expensive storage write happen?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for 'Storage write is expensive' note in the execution table

If we wrote to storageVar twice instead of once, how would gas cost change?

A Gas cost would stay the same

B Gas cost would increase

C Gas cost would decrease

D Gas cost would be zero

💡 Hint

Refer to the 'Gas Cost' column and note that storage writes are expensive

Concept Snapshot

Gas optimization with storage:
- Storage writes cost high gas
- Use memory/stack for calculations
- Write to storage only once when needed
- Minimize storage writes to save gas
- Calculate values in memory before storage update

Full Transcript

This visual trace shows how gas optimization works by minimizing storage writes. First, variables are initialized in memory with no gas cost. Calculations happen in memory, which is cheap. Then, only one storage write is done to update the blockchain state, which is expensive. By reducing storage writes, the contract saves gas. The variable tracker shows values changing step-by-step. Key moments explain why memory is preferred for calculations and why storage writes cost more. The quiz tests understanding of variable values and gas costs at each step.

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