4 - Solidity I.

What is Ethereum?

Ethereum is a decentralized platform for building and running decentralized applications. The decentralization is achieved through a P2P network of computers called nodes, where each node maintains a copy of the world state.

While users interact with a single node at a time, the world state is represented and synchronized across all nodes using the blockchain.

Blockchain and World State

Blockchain is a list of blocks, where each block contains:

The blockchain captures the complete history of Ethereum’s world state.

The world state represents the current state of Ethereum at a given point in time. It can be recomputed from the blockchain by executing all transactions from the beginning.

Account Types

Ethereum has two types of accounts:

Externally Owned Accounts (EOA) – user accounts that:

Contract Accounts – smart contract accounts that:

Transactions vs. Calls

Transactions perform changes to the world state. All nodes must execute them, and they cost gas. There are two types:

Calls do not change the world state. They only read the current state, are executed only by the receiving node, and are gas-free (not included in the mempool).

Simplified execution of message call transaction

When a messsage call transaction is executed on Ethereum, the following steps occur (simplified):

There are different data locations used during execution. The pink ones (storage, memory, calldata) are used for reference types, while the stack is used for value types. More on this in section Data location of types.

High-level overview

Contracts

Solidity is a contract-oriented language. A contract is a collection of code (its functions) and data (its state) that resides at a specific address on the Ethereum blockchain. The contract can be created using the contract keyword. The following example creates a contract named SimpleBank:

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

contract SimpleBank {
    uint256 constant internal MIN_DEPOSIT = 1 ether;
    bool immutable licensed;
    address public owner;

    constructor(bool _licensed) {
        owner = msg.sender;
        licensed = _licensed;
    }
}

Data types

Solidity has several data types, they are divided into value types and reference types.

Value types are passed by value – copied when they are used as function arguments or returned from functions.

Reference types can be modified through multiple different names (references). The reference types have to be declared with the data area (if not clear from context) where the type will be stored (memory, storage, calldata).

* bool
* uint(8-256), int(8-256)
* address
* enum
* bytes(1-32)

* fixed-size array
* dynamic-size array
* byte array
* string
* struct
* mapping

Most important reference types

The most important reference types are:

Let’s extend our SimpleBank contract to demonstrate some of these:

struct Account {
    string name;
    uint256 balance;
}

contract SimpleBank {
    uint256 constant internal MIN_DEPOSIT = 1 ether;
    bool immutable licensed;
    address public owner;
    mapping(address => Account) public accounts;

    constructor(bool _licensed) {
        owner = msg.sender;
        licensed = _licensed;
    }

    function createAccount(string calldata name) external {
        Account memory newAccount = Account({name: name, balance: 0});
        accounts[msg.sender] = newAccount;
    }
}

We added struct Account, which is a new type that can be used to store the account information. It contains a string and a uint256.

We added a mapping accounts that maps addresses to Account structs. This allows us to store the account information for each address.

In the createAccount function above:

The msg.sender here is a special global variable that holds the address of the function caller (message sender). More about it in section [Global accessible variables].

Functions

Functions are the executable units of code and are usually defined inside a contract. Functions can be invoked internally (by moving the program counter) or externally (through a message call). They can be both overloaded and overridden. They can be extended using modifiers, which amend the function’s semantics.

function deposit() external payable returns (uint256) {
    accounts[msg.sender].balance += msg.value;
    uint256 x = accounts[msg.sender].balance;
    return x;
}

modifier onlyApprovedValue() {
    if (licensed) require(msg.value >= MIN_DEPOSIT, "Too low");
    _;
}

function deposit() external payable onlyApprovedValue returns (uint256) {
    accounts[msg.sender].balance += msg.value;
    uint256 x = accounts[msg.sender].balance;
    return x;
}

Globally available

Solidity provides several globally accessible variables that give context about the current transaction and blockchain state and some units.

Variables

These special variables are available in any function without declaration.

Following two identify the different callers in a transaction:

• msg.sender – the immediate caller of the function (changes for each contract in a call chain)
• tx.origin – the original external account that initiated the entire transaction (remains the same throughout the entire transaction, even in multi-contract calls)

This distinction is important in multi-contract call chains where one contract calls another.

The msg.sender and tx.origin are equal in the first contract in the call chain (the contract that is being called). If this contract calls another contract, the msg.sender will be the address of the first contract and tx.origin will be the address of the original external account that initiated the entire transaction.

Other additional variables, that provide context about the execution includes:

• msg.value – the amount of ETH (in wei) sent with the function call
• msg.data – the complete calldata of the function call
• tx.gasprice – the gas price of the current transaction
• block.number – the current block number
• block.timestamp – the current block timestamp
• …​ more in https://docs.soliditylang.org/en/stable/units-and-global-variables.html

wei   – 1 wei   = 1     = 10^-18 ETH
gwei  – 1 gwei  = 10^9  = 10^-9  ETH
ether – 1 ether = 10^18 = 10^18  wei

1 == 1 seconds
1 minutes == 60 seconds
1 hours == 60 minutes
1 days == 24 hours
1 weeks == 7 days

Events

Events are an abstraction atop EVM’s logging functionality. Smart contracts should emit events when they make important state changes. Off-chain components can subscribe to the events and react to them – for example, a frontend application can display changes of state to a user.

Events are declared using the event keyword and can have indexed parameters to enable filtering. Let’s add events to our SimpleBank:

event AccountCreated(address indexed account, string name);
event Deposit(address indexed account, uint256 amount);

function createAccount(string calldata name) external {
    Account memory newAccount = Account({name: name, balance: 0});
    accounts[msg.sender] = newAccount;
    emit AccountCreated(msg.sender, name);
}

function deposit() external payable onlyApprovedValue returns (uint256) {
    accounts[msg.sender].balance += msg.value;
    uint256 x = accounts[msg.sender].balance;
    emit Deposit(msg.sender, msg.value);
    return x;
}

Errors and revert statements

Transactions may not always end with a successful state transition. Reasons for failure include wrong inputs, insufficient funds, or access control violations. When an error occurs, the transaction is reverted:

Errors are declared using the error keyword and can have parameters (similar to events). Let’s add custom errors to our SimpleBank:

error DepositTooLow();

modifier onlyApprovedValue() {
    if (licensed) require(msg.value >= MIN_DEPOSIT, DepositTooLow());
    _;
}

Create a new contract

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

contract HelloToken {
    // TODO
}

Variables

Name of your token.

string private _name;

Symbol of your token.

string private _symbol;

Number of decimals. Decimals are usually set to 18 to mimic the properties of Ether. This means that 1 token is 1 * 10^18.

uint8 private _decimals;

Total supply of your token.

uint256 private _totalSupply;

Mapping, which holds the account balances, eg. _balances[alice] = 10.

mapping (address => uint256) private _balances;

Mapping, which holds transfer allowances from a sender to a recipient. The recipient can spend the allowance on behalf of the sender.

mapping (address => mapping (address => uint256)) private _allowances;

Events

Define events for logging the state transitions.

event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);

Constructor

Is called during the contract deployment. It initializes the state of the contract and produces the final bytecode that gets deployed to the network.

constructor () public {
    _name = "HelloToken";
    _symbol = "HELLO";
    _decimals = 18;
}

Getter functions

function name() public view returns (string memory) {
    return _name;
}

function symbol() public view returns (string memory) {
    return _symbol;
}

function decimals() public view returns (uint8) {
    return _decimals;
}

function totalSupply() public view returns (uint256) {
    return _totalSupply;
}

Token balance of the specific address.

function balanceOf(address account) public view returns (uint256) {
    return _balances[account];
}

Supply functions

Mints new tokens specified by the amount to the specified address. Increases the total supply.

function _mint(address account, uint256 amount) internal {
    _totalSupply += amount;
    _balances[account] += amount;
    emit Transfer(address(0), account, amount);
}

Burns amount of the token from the specified address, decreases the total supply.

function _burn(address account, uint256 amount) internal {
    require(_balances[account] >= amount, "ERC20: burn amount exceeds balance");
    _balances[account] -= amount;
    _totalSupply -= amount;
    emit Transfer(account, address(0), amount);
}

Now you can add this line to your constructor. It will mint fixed amount of the token during the deployment to the deployer’s address.

_mint(msg.sender, 1000 * 10 ** _decimals);

Allowance functions

Get the allowance amount from the owner to a spender.

function allowance(address owner, address spender) public view returns (uint256) {
    return _allowances[owner][spender];
}

Set the allowance amount to the spender.

function approve(address spender, uint256 amount) public returns (bool) {
    _allowances[msg.sender][spender] = amount;
    emit Approval(msg.sender, spender, amount);
    return true;
}

Transfer functions

Transfers the specified amount from the owner to the recipient.

function transferFrom(address owner, address recipient, uint256 amount) public returns (bool) {
    require(allowance(owner, msg.sender) >= amount, "ERC20: transfer amount exceeds allowance");
    require(_balances[owner] >= amount, "ERC20: transfer amount exceeds balance");
    _balances[owner] -= amount;
    _balances[recipient] += amount;
    _allowances[owner][msg.sender] -= amount;
    emit Transfer(owner, recipient, amount);
    return true;
}

Transfers the specified amount to the recipient.

function transfer(address recipient, uint256 amount) public returns (bool) {
    return transferFrom(msg.sender, recipient, amount);
}

Compile, deploy & interact

Compile your contract, deploy it locally to a Javascript VM or the Ganache (Web 3 Provider in the Remix IDE). Transfer some tokens from address A to address B.