Storage vs memory vs calldata in Blockchain / Solidity - Visual Side-by-Side Comparison

Concept Flow - Storage vs memory vs calldata

Function Call

↓

Parameters Passed

↓

Calldata (Read-only, cheap)

↓

Memory (Temporary, modifiable)

↓

Storage (Persistent, expensive)

↓

Function Execution

↓

End of Execution

When a function is called, inputs come as calldata (read-only). Data can be copied to memory (temporary, modifiable). Storage holds persistent data on blockchain, which is expensive to read/write.

Execution Sample

Blockchain / Solidity

contract Example {
  uint storedData;
  function setData(uint x) public {
    uint temp = x; // memory
    storedData = temp; // storage
  }
}

This contract sets a stored value by copying input from calldata to memory, then to storage.

Execution Table

Step	Variable	Location	Value	Action
1	x	calldata	5	Function called with input 5
2	temp	memory	5	Copy x from calldata to memory
3	storedData	storage	5	Write temp value to storage
4	-	-	-	Function execution ends

💡 Function ends; calldata is discarded, memory cleared, storage keeps value

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
x (calldata)	-	5	5	5	-
temp (memory)	-	-	5	5	-
storedData (storage)	0	0	0	5	5

Key Moments - 3 Insights

Why can't we modify calldata variables directly?

Calldata is read-only as shown in step 1 of execution_table; to modify data, we copy it to memory (step 2).

Why is storage more expensive than memory?

Storage persists on blockchain and costs gas to read/write (step 3), while memory is temporary and cheaper.

What happens to memory and calldata after function ends?

Both calldata and memory are cleared after execution (exit_note), only storage keeps data.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'temp' after step 2?

A -

B 0

C 5

D Undefined

💡 Hint

Check the 'Value' column for 'temp' at step 2 in execution_table

At which step is the value written to storage?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Action' column in execution_table for when 'storedData' changes

If we tried to modify 'x' directly, what would happen?

A It would cause an error because calldata is read-only

B It would modify calldata successfully

C It would modify storage instead

D It would modify memory automatically

💡 Hint

Refer to key_moments about why calldata is read-only and step 1 in execution_table

Concept Snapshot

Storage vs Memory vs Calldata in blockchain:
- Calldata: Read-only input, cheapest, temporary
- Memory: Temporary, modifiable during function
- Storage: Persistent, expensive, saved on blockchain
Copy calldata to memory to modify; write to storage to save permanently.

Full Transcript

When a blockchain function is called, inputs come as calldata, which is read-only and cheap. To change data, we copy it to memory, which is temporary and modifiable during the function. Storage holds data permanently on the blockchain and is expensive to read or write. In the example, input 'x' is received in calldata, copied to memory as 'temp', then saved to storage as 'storedData'. After the function ends, calldata and memory are cleared, but storage keeps the data. This flow helps manage cost and data persistence efficiently.

Practice

1. Which of the following correctly describes storage in Solidity?

easy

A. It stores data permanently on the blockchain.

B. It holds temporary data only during function execution.

C. It is used for read-only input data in external functions.

D. It is a type of event logging mechanism.

Solution

1. Step 1: Understand storage role

   storage variables are saved permanently on the blockchain and persist between function calls.

2. Step 2: Compare with memory and calldata

   memory is temporary during function execution, and calldata is read-only input data for external functions.

3. Final Answer:

   It stores data permanently on the blockchain. -> Option A

4. Quick Check:

   Storage = permanent data [OK]

Hint: Storage is permanent, memory is temporary, calldata is input [OK]

Common Mistakes:

• Confusing storage with memory as temporary
• Thinking calldata can be modified
• Assuming storage is read-only

2. Which keyword is used to declare a function parameter that is read-only and passed from an external caller?

easy

A. calldata

B. storage

C. memory

D. event

Solution

1. Step 1: Identify parameter data location for external input

   Function parameters from external callers that should not be modified use calldata.

2. Step 2: Recall other data locations

   memory is for temporary data inside functions, storage is persistent, and event is unrelated to data location.

3. Final Answer:

   calldata -> Option A

4. Quick Check:

   External input = calldata [OK]

Hint: External read-only params use calldata [OK]

Common Mistakes:

• Using memory for external parameters
• Confusing event with data location
• Using storage for function parameters

3. What will be the output of this Solidity function when called externally with _data = [1, 2, 3]?

function process(uint[] calldata _data) external pure returns (uint) {
    uint sum = 0;
    for (uint i = 0; i < _data.length; i++) {
        sum += _data[i];
    }
    return sum;
}

medium

A. Runtime error

B. 6

C. Compilation error

D. 0

Solution

1. Step 1: Understand calldata usage

   The function receives an array _data as calldata, which is read-only but accessible for reading elements.

2. Step 2: Calculate sum of array elements

   Sum of [1, 2, 3] is 1 + 2 + 3 = 6, which is returned.

3. Final Answer:

   6 -> Option B

4. Quick Check:

   Sum of input array = 6 [OK]

Hint: Sum array elements from calldata works like memory [OK]

Common Mistakes:

• Thinking calldata cannot be read
• Expecting compilation error due to calldata
• Confusing sum calculation logic

4. Identify the error in this Solidity function:

function updateData(uint[] calldata _input) external {
    _input[0] = 10;
}

medium

A. Calldata arrays cannot be passed as parameters.

B. Function must be marked pure.

C. Missing return statement.

D. Cannot assign to calldata array elements.

Solution

1. Step 1: Check mutability of calldata

   calldata is read-only, so assigning to _input[0] causes an error.

2. Step 2: Validate other options

   The function can be non-pure, no return needed, and calldata arrays are allowed as parameters.

3. Final Answer:

   Cannot assign to calldata array elements. -> Option D

4. Quick Check:

   Calldata is read-only [OK]

Hint: Calldata arrays are read-only, no assignment allowed [OK]

Common Mistakes:

• Trying to modify calldata elements
• Thinking pure is required here
• Assuming return is mandatory

5. You want to write a Solidity function that accepts a large array from an external caller, processes it temporarily, and then stores the result permanently. Which combination of data locations should you use for the parameter and the storage variable?

hard

A. Parameter as memory, storage variable as calldata

B. Parameter as storage, storage variable as memory

C. Parameter as calldata, storage variable as storage

D. Parameter as calldata, storage variable as memory

Solution

1. Step 1: Choose parameter data location for large external input

   calldata is efficient and read-only for large external arrays, avoiding unnecessary copying.

2. Step 2: Choose storage variable for permanent data

   To keep data permanently on blockchain, use storage for the variable that stores the processed result.

3. Final Answer:

   Parameter as calldata, storage variable as storage -> Option C

4. Quick Check:

   External input = calldata, permanent store = storage [OK]

Hint: Use calldata for input, storage for permanent save [OK]

Common Mistakes:

• Using memory for large external input (inefficient)
• Trying to store permanent data in memory or calldata
• Confusing storage and memory roles