Smart contract concept in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Smart contract concept

Start: Deploy Contract

↓

Contract Stored on Blockchain

↓

User Sends Transaction

↓

Contract Code Executes

↓

Check Conditions

↓

Update State

↓

Emit Events

↓

Transaction Complete

This flow shows how a smart contract is deployed, then how it runs when a user sends a transaction, checking conditions and updating state or rejecting the transaction.

Execution Sample

Blockchain / Solidity

contract SimpleStore {
  int storedData;
  function set(int x) public {
    storedData = x;
  }
  function get() public view returns (int) {
    return storedData;
  }
}

A simple smart contract that stores a number and lets users set or get it.

Execution Table

Step	Action	Input	State Before	State After	Output
1	Deploy contract	N/A	No contract	Contract deployed with storedData=0	N/A
2	Call set(42)	42	storedData=0	storedData=42	Transaction success
3	Call get()	N/A	storedData=42	storedData=42	Returns 42
4	Call set(100)	100	storedData=42	storedData=100	Transaction success
5	Call get()	N/A	storedData=100	storedData=100	Returns 100
6	Call set(-1)	-1 (invalid)	storedData=100	storedData=-1	Transaction success (no check in code)

💡 Execution stops after last transaction; smart contract runs code on each call updating or returning state.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6
storedData	0	42	42	100	100	-1

Key Moments - 3 Insights

Why does calling get() not change storedData?

Because get() is a view function that only reads storedData without modifying it, as shown in execution_table step 3 and 5 where state before and after remain the same.

What happens if we try to set a negative number?

In this simple contract, there is no check for negative numbers, so storedData changes to -1 anyway (step 6), but in real contracts you should add checks to prevent invalid data.

Why does the contract keep its state between calls?

Because the contract is stored on the blockchain and its variables like storedData persist between transactions, as seen in variable_tracker showing storedData values after each step.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of storedData after step 4?

A 42

B 100

C 0

D -1

💡 Hint

Check the 'State After' column in row for step 4 in execution_table.

At which step does the contract return the value 42?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the 'Output' column in execution_table for the step returning 42.

If we add a check to reject negative numbers in set(), what would happen at step 6?

A Transaction is rejected, storedData stays 100

B storedData changes to -1

C Contract crashes

D storedData resets to 0

💡 Hint

Refer to key_moments about input validation and execution_table step 6.

Concept Snapshot

Smart contracts are programs on the blockchain.
They run when users send transactions.
They store and update data persistently.
Functions can change state or just read it.
Transactions succeed or fail based on code logic.

Full Transcript

A smart contract is a program deployed on the blockchain that stores data and runs code when users send transactions. When deployed, it starts with initial state. Users call functions like set() to change stored data or get() to read it. Each call runs the contract code, checks conditions, updates state if allowed, and returns results. The contract keeps its state between calls because it lives on the blockchain. This example shows a simple contract storing a number. Calls to set() update the number, calls to get() return it without changing state. Without input checks, invalid data can be stored, so real contracts add validations. This visual trace helps understand how smart contracts execute step-by-step.

Practice

1. What is a smart contract in blockchain technology?

easy

A. A type of cryptocurrency wallet

B. A program that runs on a blockchain to automate agreements

C. A physical contract signed by two parties

D. A blockchain mining algorithm

Solution

1. Step 1: Understand the definition of smart contracts

   Smart contracts are computer programs that run on blockchains to automate and enforce agreements without middlemen.

2. Step 2: Compare options with the definition

   Only A program that runs on a blockchain to automate agreements describes a program on blockchain automating agreements. Other options describe unrelated concepts.

3. Final Answer:

   A program that runs on a blockchain to automate agreements -> Option B

4. Quick Check:

   Smart contract = automated blockchain program [OK]

Hint: Smart contracts are code on blockchain, not physical papers [OK]

Common Mistakes:

• Confusing smart contracts with physical contracts
• Thinking smart contracts are wallets or mining tools
• Assuming smart contracts require middlemen

2. Which of the following is the correct way to start a simple smart contract in Solidity?

easy

A. contract MyContract { }

B. class MyContract { }

C. function MyContract() { }

D. module MyContract { }

Solution

1. Step 1: Recall Solidity syntax for defining contracts

   In Solidity, smart contracts start with the keyword contract followed by the contract name and braces.

2. Step 2: Check each option's syntax

   contract MyContract { } uses contract keyword correctly. Options A, B, and C use keywords from other languages or incorrect syntax.

3. Final Answer:

   contract MyContract { } -> Option A

4. Quick Check:

   Solidity contracts start with 'contract' keyword [OK]

Hint: Solidity contracts start with 'contract' keyword, not class or function [OK]

Common Mistakes:

• Using 'class' instead of 'contract' keyword
• Confusing functions with contract declarations
• Using module or other unrelated keywords

3. What will be the output of this Solidity function when called?

function getValue() public pure returns (uint) { return 5 + 3; }

medium

A. Error

B. 53

C. 8

D. 0

Solution

1. Step 1: Analyze the function logic

   The function returns the sum of 5 and 3, which is 8.

2. Step 2: Understand Solidity return behavior

   The function is marked pure and returns a uint, so it will output the calculated value 8 without errors.

3. Final Answer:

   8 -> Option C

4. Quick Check:

   5 + 3 = 8 [OK]

Hint: Add numbers inside function to get output quickly [OK]

Common Mistakes:

• Thinking '5 + 3' concatenates as '53'
• Expecting runtime error due to missing state
• Assuming default return is zero

4. Identify the error in this Solidity smart contract snippet:

contract Test {
  uint value;
  function setValue(uint _value) public {
    value = _value
  }
}

medium

A. Missing semicolon after assignment

B. Incorrect function visibility

C. Variable 'value' should be public

D. Function name should be 'set_value'

Solution

1. Step 1: Check syntax line by line

   The line value = _value is missing a semicolon at the end, which is required in Solidity.

2. Step 2: Verify other parts

   Function visibility 'public' is correct, variable can be private, and function naming is valid. So only missing semicolon is error.

3. Final Answer:

   Missing semicolon after assignment -> Option A

4. Quick Check:

   Semicolons end statements in Solidity [OK]

Hint: Check for missing semicolons after statements [OK]

Common Mistakes:

• Ignoring missing semicolon errors
• Thinking function visibility is wrong
• Assuming variable must be public

5. You want to create a smart contract that stores user balances and allows deposits only if the amount is positive. Which Solidity code snippet correctly enforces this?

hard

A. function deposit(uint amount) public {
if(amount >= 0) {
balances[msg.sender] = amount;
}
}

B. function deposit(uint amount) public {
balances[msg.sender] += amount;
}

C. function deposit(int amount) public {
balances[msg.sender] += amount;
}

D. function deposit(uint amount) public {
require(amount > 0, "Amount must be positive");
balances[msg.sender] += amount;
}

Solution

1. Step 1: Check input validation for positive amount

   function deposit(uint amount) public { require(amount > 0, "Amount must be positive"); balances[msg.sender] += amount; } uses require(amount > 0) to ensure only positive deposits are accepted.

2. Step 2: Compare other options for correctness

   function deposit(uint amount) public { if(amount >= 0) { balances[msg.sender] = amount; } } allows zero and overwrites balance instead of adding. function deposit(int amount) public { balances[msg.sender] += amount; } uses signed int allowing negative deposits. function deposit(uint amount) public { balances[msg.sender] += amount; } lacks any check.

3. Final Answer:

   function deposit(uint amount) public { require(amount > 0, "Amount must be positive"); balances[msg.sender] += amount; } -> Option D

4. Quick Check:

   Use require() to enforce positive deposits [OK]

Hint: Use require() to check conditions before updating state [OK]

Common Mistakes:

• Not validating input amounts
• Using signed integers for balances
• Overwriting balances instead of adding