Introduction

Smart contract: Simply a program that runs on the Ethereum blockchain, has specific address on blockchain, not controlled by a user.

Ethereum virtual machine (EVM): It’s the environment to Ethereum accounts and smart contracts live.

Solidity: A high-level programming language, use to develop smart contracts.

Remix: An online IDE allows develop, compile, deploy smart contracts for Ethereum.

Here is a simple example of Smart Contract:

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.1 <0.9.0;

contract Message {
    string private message;
    
    constructor()  {
        message = "hello world1";
    }
    
    function setMessage(string memory mes) public {
        message = mes;
    }
    
    function getMessage() view public returns(string memory) {
        return message;
    }
}

Smart Contracts life cycle

As shown in the above figure, the smart contract life cycle follows the steps below :

• A Smart contract is implemented using a high level language such as Solidity.
• Smart contract is compiled to two results that specifically are: Bytecode (which is a stack-based machine language compiled and executable by the EVM) and an ABI – Application Binary Interface (which is a JSON file that describes the distributed contract and the functions of the smart contract). The ABI is the bridge between Web2 and Web3.
• After that, the smart contract is deployed. This consists of creating a transaction packing the smart contract bytecode, and sending it to the network. The transaction gets its own contract account which has an address, a balance, a Nonce, and holds the bytecode in the data field.
• Finally, a Smart contract is invoked. This consists of external calls to the smart contract.

Special note:

• When a contract is created, the constructor function is executed once and that first call is always triggered by an EOA account (Externally Owned Account).
• A smart contract is not self-executable. It requires an external call to be executed.
• Once it is executed, transactions resulting from the execution are transcribed on the blockchain and eventually smart contracts meta data are updated.

Solidity: Variables and Functions

Variables

The following value types:

The concept of “undefined” or “null” values does not exist in Solidity.

There are three types of variables:

• State Variables: Variables whose values are permanently stored in a contract storage.
• Local Variables: Variables whose values are present till function is executing.
• Global Variables: Special variables exists in the global namespace used to get information about the blockchain.

Syntax:

<type> <access-modifier> <variable-name> ;

Example:

uint public age;

State Variable Scope:

Functions

Syntax:

function <function-name>(<parameter-list>) <scope> returns(<return-type-list>)  { 
    // block code
 }

Example:

function getSender() public returns (address) {
    return msg.sender;
}

Function Scope:

Cryptocurrency example

The following contract implements the simplest form of a cryptocurrency

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.1 <0.9.0;

contract PBCoin {
    address private owner;
    mapping(address => uint) balances;

    event Sent(address from, address to, uint amount);
    
    constructor() {
        owner = msg.sender;
        balances[owner] = 1000000;
    }
    
    function send(address receiver, uint amount) public {
        require(amount <= balances[msg.sender]);
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Sent(msg.sender, receiver, amount);
    }
    
    function getBalance(address receiver) view public returns(uint) {
        return balances[receiver];
    }
}

References

https://docs.soliditylang.org/en/v0.8.16/introduction-to-smart-contracts.html

https://remix.ethereum.org/