Solidity Data Types

Introduction to smart contractsSearch on YouTubeBookmarkSaved

If Python is used to write normal programs, what do we use to write an Ethereum smart contract? Solidity.

• Solidity: a high-level programming language designed mainly for writing smart contracts on Ethereum-compatible blockchains.
• Smart contract: a program deployed to a blockchain, containing both data/state and functions/logic.
• EVM: the Ethereum Virtual Machine executes the compiled smart-contract bytecode.

Remix IDESearch on YouTubeBookmarkSaved

Code is written in the Remix platform at app.remix.live, a browser IDE. It has a file explorer, editor, compiler, deployer and terminal.

Creating the first contract: Hello WorldSearch on YouTubeBookmarkSaved

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

contract HelloWorld {

    string public message = "Hello, Blockchain!";

}

The state variable line has four parts:

string      public       message          = "Hello, Blockchain!";
data type   visibility   variable name      initial value

State variableSearch on YouTubeBookmarkSaved

In most programs, a variable lives in RAM and disappears when the program stops. In Solidity, variables declared at contract level (outside any function) are state variables. They are written permanently into blockchain storage, the EVM's "hard drive". This acts like a permanent row in a decentralised database.

Modifying a state variable costs real money (gas). Reading it is free.

Data typesSearch on YouTubeBookmarkSaved

Solidity is statically typed: every variable's type must be declared explicitly at compile time. string is a dynamically sized array of characters used to hold text.

Visibility modifiers and "free" gettersSearch on YouTubeBookmarkSaved

Visibility modifiers decide who or what may read or modify a variable. Declaring a state variable public makes the compiler generate a getter function automatically. You do not need to write getMessage(). Anyone in the world can then query the blockchain for the value.

Compiling in RemixSearch on YouTubeBookmarkSaved

In the Solidity Compiler tab:

The ABI is a JSON array that defines all public functions, state variable getters, parameters and return types. Front ends (React, Web3.js, Ethers.js) need it to encode function calls.

The bytecode has two parts:

• Creation bytecode runs once during deployment. It executes the constructor and stores the runtime code on chain.
• Runtime bytecode is stored at the contract address. It runs whenever external accounts interact with the contract.

Deploying in RemixSearch on YouTubeBookmarkSaved

The Deploy & Run Transactions tab deploys compiled bytecode to a simulated or live chain and lets you interact with its state.

Click Deploy. What you observe:

1. The account balance drops slightly. Writing to the blockchain is never free. Deployment used gas, and the EVM charged the deployer for storing the bytecode.
2. Under Deployed Contracts the contract appears with its own address. It is an independent entity that can even hold its own cryptocurrency. Apps and users must target this address.
3. The blue message button is the auto-generated read-only getter. Querying it costs zero gas.
4. The terminal shows the permanent deployment record: sender address, bytecode payload (data) and transaction hash.

State-changing functionsSearch on YouTubeBookmarkSaved

A function is a self-contained block of code that performs a specific task.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract HelloWorld {

    string public message = "Hello, Blockchain!";

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

• function setMessage(...) public { ... }: unlike the read-only getter, this function changes permanent blockchain state. It cannot be called for free. The user must broadcast a transaction, sign it with a wallet, and pay gas. public means anyone can call it and change the message.
• string memory newMessage: the memory keyword. Complex data (strings, arrays, structs) must state where it lives, because storage is expensive. memory marks a temporary variable that exists only while the function runs and is then wiped.
• message = newMessage;: state overwrite. The temporary user input overwrites the permanent state variable. message implicitly lives in storage, so assigning a memory value to it moves temporary input into permanent blockchain history.

In Remix, the deployed contract now shows an orange setMessage button (a transaction) and a blue message button (a call). Enter "Welcome to IIIT Kottayam", click transact, then call message to see the new value.

Value typesSearch on YouTubeBookmarkSaved

uint is an alias of uint256 and int of int256. Smaller sizes exist in steps of 8 bits (uint8 to uint256). Unassigned variables take a default value: 0, false, "" or the zero address.

State variable vs local variableSearch on YouTubeBookmarkSaved

contract VariableDemo {

    uint256 public stateNumber = 10;     // state variable

    function test() public {
        uint256 localNumber = 20;        // local variable
    }
}

Where a variable is declared decides its lifespan, its location in the EVM and its gas cost.

Constant and immutableSearch on YouTubeBookmarkSaved

uint256 public constant MAX_STUDENTS = 100;
address public immutable owner;

• A constant must be set at declaration and cannot change after compilation.
• An immutable is assigned once, usually in the constructor, and cannot change afterwards.

Both are embedded in the contract's code instead of storage, which saves a lot of gas.

contract Registry {
    uint256 public constant MAX_STUDENTS = 100;
    address public immutable owner;

    constructor() {
        owner = msg.sender;     // set once at deployment
    }
}

EVM memory managementSearch on YouTubeBookmarkSaved

The EVM manages data in five locations, each with its own rules for mutability, lifespan and gas.

function setName(string calldata newName) external {   // read-only input, cheaper
    name = newName;                                      // copied into storage
}

ExercisesSearch on YouTubeBookmarkSaved

Exercise 1 and 2: StudentProfileSearch on YouTubeBookmarkSaved

Exercise 1: create StudentProfile with state variables for student name, roll number and department. Write separate functions to set each one. Deploy in Remix and verify the stored values. Exercise 2: add a single function that takes name, roll number and department and updates all three at once.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract StudentProfile {
    string public studentName;
    uint256 public rollNumber;
    string public department;

    function setName(string memory _name) public {
        studentName = _name;
    }

    function setRollNumber(uint256 _roll) public {
        rollNumber = _roll;
    }

    function setDepartment(string memory _dept) public {
        department = _dept;
    }

    // Exercise 2: update all three at once
    function setProfile(string memory _name, uint256 _roll, string memory _dept) public {
        studentName = _name;
        rollNumber = _roll;
        department = _dept;
    }
}

Exercise 3 and 4: StudentDataSearch on YouTubeBookmarkSaved

Exercise 3: create StudentData with name, roll number, age, CGPA, graduation status, department and wallet address. Choose the best type for each, initialise them, deploy, and check the getters. Exercise 4: add functions to update name, age, CGPA and graduation status, and verify each change.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract StudentData {
    string  public studentName   = "Alice";
    uint256 public rollNumber    = 2022101;
    uint8   public age           = 21;
    uint256 public cgpa          = 875;      // 8.75, two implied decimals
    bool    public isGraduated   = false;
    string  public department    = "Cyber Security";
    address public studentWallet = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;

    // Exercise 4
    function updateName(string memory _name) public { studentName = _name; }
    function updateAge(uint8 _age) public { age = _age; }
    function updateCgpa(uint256 _cgpa) public { cgpa = _cgpa; }
    function updateGraduation(bool _status) public { isGraduated = _status; }
}

Address literals must be in checksum (mixed-case) form or the compiler rejects them. The address above is Remix VM's first test account.

Quick self-testSearch on YouTubeBookmarkSaved