Contract structure and syntax in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Contract structure and syntax

Start Contract

↓

Declare Contract Name

↓

Define State Variables

↓

Write Functions

↓

Add Constructor (optional)

↓

Close Contract

This flow shows the basic steps to write a contract: start, name it, add variables, write functions, optionally add a constructor, then close.

Execution Sample

Blockchain / Solidity

contract Simple {
  uint count;
  function increment() public {
    count += 1;
  }
}

A simple contract named Simple with a variable count and a function to increase it by 1.

Execution Table

Step	Action	Code Line	Effect	State Change
1	Start contract declaration	contract Simple {	Contract named Simple created	No state variables yet
2	Declare state variable	uint count;	Variable count of type uint declared	count = 0 (default)
3	Define function increment	function increment() public {	Function increment created	No state change
4	Increment count	count += 1;	count increased by 1	count = 1
5	Close function	}	Function increment ends	count = 1
6	Close contract	}	Contract Simple ends	Final state: count = 1

💡 Contract code ends after closing brace, state variable count is 1 after increment function call

Variable Tracker

Variable	Start	After Step 4	Final
count	0 (default)	1	1

Key Moments - 3 Insights

Why do we declare variables outside functions?

Variables declared outside functions are state variables stored on the blockchain, as shown in step 2 where count is declared before functions.

What does 'public' mean in the function declaration?

'public' means the function can be called from outside the contract, allowing interaction, as seen in step 3.

Why is the contract closed with a '}'?

The closing brace '}' marks the end of the contract code block, as in step 6, signaling no more code inside the contract.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of count after step 2?

A undefined

B 1

C 0

D Error

💡 Hint

Check the 'State Change' column at step 2 in the execution table.

At which step does the count variable increase?

A Step 4

B Step 2

C Step 3

D Step 6

💡 Hint

Look for the action 'Increment count' in the execution table.

If we remove the closing brace at step 6, what happens?

A Contract compiles successfully

B Syntax error, contract not closed

C Function increment won't work

D count variable resets

💡 Hint

The exit note says the contract ends after the closing brace; missing it causes syntax errors.

Concept Snapshot

Contract structure:
- Start with 'contract Name {'.
- Declare state variables outside functions.
- Write functions inside contract.
- Use visibility keywords like 'public'.
- Close contract with '}'.
- State variables hold data on blockchain.

Full Transcript

This visual trace shows how a simple blockchain contract is structured and how its syntax works. We start by declaring the contract with a name. Then we declare state variables outside functions to store data on the blockchain. Next, we write functions inside the contract to manipulate these variables. Functions can have visibility like 'public' to allow external calls. The contract code ends with a closing brace. The execution table traces each step, showing how the variable 'count' starts at zero and increases by one when the increment function runs. Key moments clarify common confusions about variable placement, function visibility, and code block closure. The quiz tests understanding of variable values at steps, when changes happen, and syntax rules. This helps beginners see how contract structure and syntax work together to create blockchain programs.

Practice

1.

What is the correct way to start defining a contract named SimpleStorage in Solidity?

easy

A. contract SimpleStorage { }

B. class SimpleStorage { }

C. function SimpleStorage() { }

D. module SimpleStorage { }

Solution

1. Step 1: Understand Solidity contract declaration

   In Solidity, contracts are declared using the keyword contract followed by the contract name and curly braces.

2. Step 2: Match the syntax with the options

   Only contract SimpleStorage { } uses contract SimpleStorage { }, which is the correct syntax to start a contract.

3. Final Answer:

   contract SimpleStorage { } -> Option A

4. Quick Check:

   Contract declaration = contract SimpleStorage { } [OK]

Hint: Look for 'contract' keyword to start a contract [OK]

Common Mistakes:

• Using 'class' instead of 'contract'
• Using 'function' to define contract
• Using 'module' which is not valid in Solidity

2.

Which of the following is the correct syntax to declare a state variable count of type uint inside a contract?

easy

A. uint count = 0

B. var count = uint;

C. uint count;

D. count uint;

Solution

1. Step 1: Recall Solidity variable declaration syntax

   State variables are declared by specifying the type followed by the variable name and a semicolon.

2. Step 2: Check each option

   uint count; correctly declares uint count;. uint count = 0 misses the semicolon. Options B and D use incorrect syntax.

3. Final Answer:

   uint count; -> Option C

4. Quick Check:

   Variable declaration = type name; [OK]

Hint: Remember: type then variable name, end with semicolon [OK]

Common Mistakes:

• Omitting semicolon at the end
• Using 'var' keyword which is not valid in Solidity
• Reversing type and variable name

3.

What will be the output of the following Solidity function when called?

contract Test {
    uint number = 5;
    function getNumber() public view returns (uint) {
        return number + 3;
    }
}

medium

A. 5

B. 8

C. 3

D. Compilation error

Solution

1. Step 1: Understand the variable and function

   The state variable number is set to 5. The function returns number + 3.

2. Step 2: Calculate the return value

   5 + 3 equals 8, so the function returns 8.

3. Final Answer:

   8 -> Option B

4. Quick Check:

   5 + 3 = 8 [OK]

Hint: Add variable value and constant inside return [OK]

Common Mistakes:

• Confusing variable value with function output
• Assuming function returns variable directly without addition
• Thinking there is a syntax error

4.

Identify the error in the following Solidity contract snippet:

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

medium

A. Contract name should be lowercase

B. Function increment should be private

C. Variable count should be declared inside the function

D. Missing semicolon after uint count

Solution

1. Step 1: Check variable declaration syntax

   The line uint count is missing a semicolon at the end, which is required in Solidity.

2. Step 2: Verify other parts

   Function visibility as public is valid. Variables are correctly declared outside functions. Contract names can be uppercase.

3. Final Answer:

   Missing semicolon after uint count -> Option D

4. Quick Check:

   Semicolon missing = syntax error [OK]

Hint: Check for missing semicolons after variable declarations [OK]

Common Mistakes:

• Forgetting semicolon after variable declaration
• Thinking function visibility must be private
• Assuming contract names must be lowercase

5.

You want to create a contract that stores a person's name and age, and has a function to update the age. Which of the following contract structures correctly implements this?

contract Person {
    string name;
    uint age;

    function setAge(uint newAge) public {
        age = newAge;
    }
}

hard

A. Correct: variables declared and function updates age properly

B. Incorrect: missing visibility for variables

C. Incorrect: function should return the new age

D. Incorrect: variables should be declared inside the function

Solution

1. Step 1: Check variable declarations

   Variables name and age are declared at contract level, which is correct for storing data.

2. Step 2: Check function to update age

   The function setAge takes a parameter and assigns it to age, correctly updating the state variable.

3. Final Answer:

   Correct: variables declared and function updates age properly -> Option A

4. Quick Check:

   State variables + update function = correct contract [OK]

Hint: State variables outside, update functions inside contract [OK]

Common Mistakes:

• Declaring variables inside functions instead of contract
• Expecting update functions to return values unnecessarily
• Forgetting to declare variables at contract level