AI/ 007 / Smart contract explained

By cLos787

Smart Contracts: A Beginner’s Guide

Have you ever heard of smart contracts? If not, don’t worry. In this blog post, we will be discussing what smart contracts are and how to write a simple smart contract code.

A smart contract is a self-executing computer program with the rules of the agreement between buyer and seller being directly written into lines of code. The code and the agreements contained within it exist on a blockchain network and execute automatically.

Let’s write a simple smart contract to understand the concept better. The code we will be writing is for a token contract, which is a type of smart contract that helps you issue and manage your own cryptocurrency.

Here is the code for our simple smart contract:

				
					pragma solidity ^0.8.0;

contract SimpleToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;

    constructor(uint256 _totalSupply) public {
        totalSupply = _totalSupply;
        balanceOf[msg.sender] = totalSupply;
    }

    function transfer(address _to, uint256 _value) public {
        require(balanceOf[msg.sender] >= _value && _value > 0, "transfer failed");
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;
    }
}

Let’s break down the code to understand what each line does:

pragma solidity ^0.8.0;: This line specifies the version of the Solidity compiler that we are using.
contract SimpleToken {: This line declares a new smart contract called SimpleToken.
uint256 public totalSupply;: This line declares a public variable totalSupply of type uint256. This variable will keep track of the total supply of tokens.
mapping(address => uint256) public balanceOf;: This line declares a public mapping balanceOf where the keys are addresses and the values are uint256. This mapping will keep track of the balance of each address.
constructor(uint256 _totalSupply) public {: This line declares the constructor of the contract. The constructor is called when the contract is deployed and it takes an input _totalSupply of type uint256.
totalSupply = _totalSupply;: This line sets the value of totalSupply to the input value _totalSupply.
balanceOf[msg.sender] = totalSupply;: This line sets the balance of the contract deployer to the total supply of tokens.
function transfer(address _to, uint256 _value) public {: This line declares a public function transfer that takes two inputs: an address _to and a uint256 value _value.
require(balanceOf[msg.sender] >= _value && _value > 0, "transfer failed");: This line checks if the balance of the sender is greater than or equal to the value being transferred and if the value being transferred is greater than 0. If either of these conditions are not met, the function will stop executing and throw an error message “transfer failed”.
balanceOf[msg.sender] -= _value;: This
line subtracts the value being transferred from the sender’s balance.
1. balanceOf[_to] += _value;: This line adds the value being transferred to the recipient’s balance.
2. }: This closes the transfer function.
3. }: This closes the SimpleToken contract.
That’s it! This is a simple example of how to write a smart contract. You can deploy this contract on a blockchain network, such as Ethereum, and start issuing and transferring tokens.
In conclusion, smart contracts are self-executing computer programs that allow for the creation of trustless and transparent agreements. By writing the rules of the agreement in code, smart contracts eliminate the need for intermediaries, making transactions faster and more secure.
I hope this blog post has helped you understand what smart contracts are and how to write a simple smart contract code.