State variables in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - State variables

Contract deployed

↓

State variables created in storage

↓

Function called

↓

Read or update state variables

↓

State variables persist after function ends

↓

Next function call uses updated state

State variables are stored on the blockchain and keep their values between function calls in a smart contract.

Execution Sample

Blockchain / Solidity

contract Example {
  uint count;
  function increment() public {
    count = count + 1;
  }
  function getCount() public view returns (uint) {
    return count;
  }
}

This contract has a state variable 'count' that increments each time 'increment' is called and can be read with 'getCount'.

Execution Table

Step	Action	State Variable 'count'	Output
1	Contract deployed	0 (default)	None
2	Call increment()	count = 0 + 1 = 1	None
3	Call getCount()	count = 1	Returns 1
4	Call increment()	count = 1 + 1 = 2	None
5	Call getCount()	count = 2	Returns 2
6	End of calls	count = 2	State persists on blockchain

💡 Execution stops after calls; state variable 'count' keeps its last value on blockchain.

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
count	0	1	2	2

Key Moments - 2 Insights

Why does the value of 'count' not reset to 0 after each function call?

Because 'count' is a state variable stored on the blockchain, it keeps its value between calls as shown in steps 2, 3, 4, and 5 in the execution_table.

What happens if we call 'getCount' before any 'increment' calls?

The value returned would be 0, the default initial value of the state variable 'count', as shown in step 1 where 'count' starts at 0.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'count' after the first call to increment()?

A 0

B 1

C 2

D Undefined

💡 Hint

Check Step 2 in the execution_table where 'count' is updated to 1.

At which step does the 'getCount()' function return the value 2?

A Step 5

B Step 3

C Step 2

D Step 4

💡 Hint

Look at Step 5 in the execution_table where 'getCount()' returns 2.

If we never call 'increment()', what will 'getCount()' return?

A Error

B 1

C 0

D Undefined

💡 Hint

Refer to Step 1 in the execution_table where 'count' starts at 0.

Concept Snapshot

State variables store data permanently on the blockchain.
They keep their values between function calls.
Declared inside contracts but outside functions.
Updated by functions and persist after execution.
Used to track contract state like counters or balances.

Full Transcript

State variables in blockchain smart contracts are special variables that store data permanently on the blockchain. When a contract is deployed, these variables are created in the blockchain's storage with default values. Functions in the contract can read or update these state variables. Unlike local variables, state variables keep their values between function calls, so changes persist on the blockchain. For example, a 'count' variable can be incremented by calling a function, and its updated value remains stored for future calls. This behavior is shown step-by-step in the execution table, where 'count' starts at 0, increments to 1, then 2, and can be read anytime. This persistence is key to tracking contract state like balances or counters.

Practice

1. What is a state variable in a blockchain smart contract?

easy

A. A variable that stores data permanently on the blockchain

B. A temporary variable used only inside functions

C. A variable that stores user input off-chain

D. A variable that resets every time a function runs

Solution

1. Step 1: Understand what state variables do

   State variables store data permanently on the blockchain, unlike local variables which are temporary.

2. Step 2: Compare options with definition

   Only A variable that stores data permanently on the blockchain describes permanent storage on the blockchain, which matches the definition of state variables.

3. Final Answer:

   A variable that stores data permanently on the blockchain -> Option A

4. Quick Check:

   State variable = permanent blockchain storage [OK]

Hint: State variables save data permanently on blockchain [OK]

Common Mistakes:

• Confusing state variables with local variables
• Thinking state variables reset after function ends
• Assuming state variables store data off-chain

2. Which of the following is the correct way to declare a state variable in Solidity?

easy

A. let count = uint256;

B. function uint256 count;

C. uint256 public count;

D. var count = 0;

Solution

1. Step 1: Recall Solidity syntax for state variables

   State variables are declared outside functions with a type and visibility, e.g., uint256 public count;.

2. Step 2: Check each option

   uint256 public count; matches correct syntax. Options A, B, and C use incorrect keywords or syntax not valid for state variables.

3. Final Answer:

   uint256 public count; -> Option C

4. Quick Check:

   State variable declaration = type + visibility + name [OK]

Hint: State variables need type and visibility outside functions [OK]

Common Mistakes:

• Using function keyword to declare variables
• Using var or let which are not Solidity keywords
• Declaring variables inside functions as state variables

3. Consider this Solidity contract snippet:

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

What will be the value of count after calling increment() three times?

medium

A. 1

B. 3

C. 0

D. Error: count is not accessible

Solution

1. Step 1: Understand initial value and increment

   The state variable count starts at 0 and increases by 1 each time increment() is called.

2. Step 2: Calculate after three calls

   After three calls, count = 0 + 1 + 1 + 1 = 3.

3. Final Answer:

   3 -> Option B

4. Quick Check:

   0 + 3 increments = 3 [OK]

Hint: Add 1 to count for each increment call [OK]

Common Mistakes:

• Forgetting count starts at 0
• Assuming count resets after each call
• Thinking count is private and inaccessible

4. Identify the error in this Solidity contract:

contract Example {
  uint256 count;
  function setCount(uint256 _count) public {
    uint256 count = _count;
  }
}

medium

A. Local variable shadows state variable inside function

B. State variable count is not declared

C. Function setCount has wrong return type

D. Missing visibility for state variable count

Solution

1. Step 1: Analyze variable declarations

   The state variable count is declared correctly. Inside setCount, a new local variable count is declared, which hides the state variable.

2. Step 2: Understand shadowing effect

   Assigning to local count does not change the state variable. This is a common mistake called variable shadowing.

3. Final Answer:

   Local variable shadows state variable inside function -> Option A

4. Quick Check:

   Local variable shadows state variable = bug [OK]

Hint: Avoid declaring local variable with same name as state variable [OK]

Common Mistakes:

• Thinking state variable is missing
• Ignoring variable shadowing
• Assuming function needs return type

5. You want to create a smart contract that stores a user's name permanently and allows updating it. Which of these is the best way to declare the state variable and update it?

hard

A. Declare string memory name; as state variable

B. Declare string name; inside the update function and assign new value there

C. Use a local variable string name; in constructor only

D. Declare string public name; as state variable and update it in a public function

Solution

1. Step 1: Understand state variable declaration for permanent storage

   State variables must be declared outside functions with proper type and visibility, e.g., string public name;.

2. Step 2: Update state variable in a public function

   To change the stored name, write a public function that assigns a new value to the state variable.

3. Final Answer:

   Declare string public name; as state variable and update it in a public function -> Option D

4. Quick Check:

   State variable + public update function = correct pattern [OK]

Hint: Declare state variable outside, update inside public function [OK]

Common Mistakes:

• Declaring variables inside functions only
• Using memory keyword for state variables
• Not providing visibility for state variables