Contract structure and syntax in Blockchain / Solidity

Introduction

A contract is like a digital agreement that runs on a blockchain. It tells the computer what to do and how to behave.

When you want to create a simple agreement that runs automatically, like a payment or a promise.

When you need to store and manage data securely on the blockchain.

When you want to build apps that work without a middleman, like games or voting systems.

When you want to make rules that everyone can trust and see on the blockchain.

Syntax

Blockchain / Solidity

contract ContractName {
    // State variables
    // Functions
}

The contract starts with the keyword contract followed by its name.

Inside the curly braces { }, you write variables and functions that define the contract's behavior.

Examples

This contract has one variable called number that stores a number.

Blockchain / Solidity

contract SimpleContract {
    uint number;
}

This contract stores a message and has a function to change it.

Blockchain / Solidity

contract Greeting {
    string public message;

    function setMessage(string memory newMessage) public {
        message = newMessage;
    }
}

Sample Program

This contract keeps a count number. It has a function to add one to the count and another to see the current count.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Counter {
    uint public count;

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

    function getCount() public view returns (uint) {
        return count;
    }
}

Important Notes

Contracts are like classes in other programming languages.

State variables store data on the blockchain and keep it safe.

Functions define what the contract can do and can be called by users.

Summary

A contract is a digital agreement that runs on the blockchain.

It starts with the contract keyword and has variables and functions inside.

Contracts help build secure and automatic programs on the blockchain.

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