DEV Community: Sergio Salanitri

ERC20 Ethereum token

Sergio Salanitri — Wed, 27 Oct 2021 13:23:50 +0000

Into the blochchain world exists the criptocurrency and others assest called tokens. In particular we show the most famous ethereum tokens. In fact the ethereum cripto currency is the natiive Etereum token. Beside we develop other kind of token in base of comunity Ethereum specifications.

What's ERC?

Ethereun as the recommendation of the minimal requirement to keep in mind at moment to implement this recommendations.
This standards specificacionts define he interface that the develop MUST add in you contract. Then , other developers and existing DApps could be access to the token using the standard intefaces.
In the practice, in Solidity this interfaces are some defined functions , state variables and events (if apply).

ERC20: Is the 20th recommendation and define how to be a token to use to transfer digital tokens between blockchain address. This token could be represent a digital assets to trade on marketplace such as DAI or use into online game as digital money and son on.
This token could be use in private economy into the Decentralize Applicarions DApps such as blockchain games or in crownfounding system in orden to get funds.
This tokens are fungibles, so fiat money. At the moment to generate the token the user define into the ERC20 smart contract the maximum supplied tokens one token in this set is indistinguishable with other token.

In order to develop ERC20 token you MUST implement at least the required function of this interface:

Functions

name:
Returns the name of the token.
OPTIONAL - This method can be used to improve usability, but interfaces and other contracts MUST NOT expect these values to be present.

function name() public view returns (string)

symbol:
Returns the symbol of the token. E.g. “DEV”.

OPTIONAL - This method can be used to improve usability, but interfaces and other contracts MUST NOT expect these values to be present.

function symbol() public view returns (string)

decimals:
Returns the number of decimals the token uses - e.g. 8, means to divide the token amount by 100000000 to get its user representation.

OPTIONAL - This method can be used to improve usability, but interfaces and other contracts MUST NOT expect these values to be present.

function decimals() public view returns (uint8)

totalSupply:
Returns the total token supply.

function totalSupply() public view returns (uint256)

balanceOf:
Returns the account balance of another account with address _owner.

function balanceOf(address _owner) public view returns (uint256 balance)

transfer:
Transfers _value amount of tokens to address _to, and MUST fire the Transfer event. The function SHOULD throw if the message caller’s account balance does not have enough tokens to spend.

Note Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event.

function transfer(address _to, uint256 _value) public returns (bool success)

transferFrom:
Transfers _value amount of tokens from address _from to address _to, and MUST fire the Transfer event.

The transferFrom method is used for a withdraw workflow, allowing contracts to transfer tokens on your behalf. This can be used for example to allow a contract to transfer tokens on your behalf and/or to charge fees in sub-currencies. The function SHOULD throw unless the _from account has deliberately authorized the sender of the message via some mechanism.

Note Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event.

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)

approve
Allows _spender to withdraw from your account multiple times, up to the _value amount. If this function is called again it overwrites the current allowance with _value.

NOTE: To prevent attack vectors like the one described here and discussed here, clients SHOULD make sure to create user interfaces in such a way that they set the allowance first to 0 before setting it to another value for the same spender. THOUGH The contract itself shouldn’t enforce it, to allow backwards compatibility with contracts deployed before

function approve(address _spender, uint256 _value) public returns (bool success)

allowance
Returns the amount which _spender is still allowed to withdraw from _owner.

function allowance(address _owner, address _spender) public view returns (uint256 remaining)

Events

Transfer:
MUST trigger when tokens are transferred, including zero value transfers.

A token contract which creates new tokens SHOULD trigger a Transfer event with the _from address set to 0x0 when tokens are created.

event Transfer(address indexed _from, address indexed _to, uint256 _value)

Approval:
MUST trigger on any successful call to approve(address _spender, uint256 _value).

event Approval(address indexed _owner, address indexed _spender, uint256 _value)

Basic ERC20 Implementation

pragma solidity ^0.4.24;

// ----------------------------------------------------------------------------
// Sample token contract
//
// Symbol        : ETN
// Name          : Sample ERC20 Token
// Total supply  : 10000000
// Decimals      : 18
// Owner Account : {{Owner Account}}
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Lib: Safe Math
// ----------------------------------------------------------------------------
contract SafeMath {

    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }

    function safeSub(uint a, uint b) public pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }

    function safeMul(uint a, uint b) public pure returns (uint c) {
        c = a * b;
        require(a == 0 || c / a == b);
    }

    function safeDiv(uint a, uint b) public pure returns (uint c) {
        require(b > 0);
        c = a / b;
    }
}


/**
ERC Token Standard #20 Interface
https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
*/
contract ERC20Interface {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);

    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}


/**
Contract function to receive approval and execute function in one call
Borrowed from MiniMeToken
*/
contract ApproveAndCallFallBack {
    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}

/**
ERC20 Token, with the addition of symbol, name and decimals and assisted token transfers
*/
contract ETNToken is ERC20Interface, SafeMath {
    string public symbol;
    string public  name;
    uint8 public decimals;
    uint public _totalSupply;
    address owner = {{Owner Account}}

    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) allowed;


    // ------------------------------------------------------------------------
    // Constructor
    // ------------------------------------------------------------------------
    constructor() public {
        symbol = "ETN";
        name = "Sample ERC20 Token";
        decimals = 18;
        _totalSupply = 10000000;
        balances[owner] = _totalSupply;
        emit Transfer(address(0), owner, _totalSupply);
    }


    // ------------------------------------------------------------------------
    // Total supply
    // ------------------------------------------------------------------------
    function totalSupply() public constant returns (uint) {
        return _totalSupply  - balances[address(0)];
    }


    // ------------------------------------------------------------------------
    // Get the token balance for account tokenOwner
    // ------------------------------------------------------------------------
    function balanceOf(address tokenOwner) public constant returns (uint balance) {
        return balances[tokenOwner];
    }


    // ------------------------------------------------------------------------
    // Transfer the balance from token owner's account to to account
    // - Owner's account must have sufficient balance to transfer
    // - 0 value transfers are allowed
    // ------------------------------------------------------------------------
    function transfer(address to, uint tokens) public returns (bool success) {
        balances[msg.sender] = safeSub(balances[msg.sender], tokens);
        balances[to] = safeAdd(balances[to], tokens);
        emit Transfer(msg.sender, to, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Token owner can approve for spender to transferFrom(...) tokens
    // from the token owner's account
    //
    // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
    // recommends that there are no checks for the approval double-spend attack
    // as this should be implemented in user interfaces 
    // ------------------------------------------------------------------------
    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Transfer tokens from the from account to the to account
    // 
    // The calling account must already have sufficient tokens approve(...)-d
    // for spending from the from account and
    // - From account must have sufficient balance to transfer
    // - Spender must have sufficient allowance to transfer
    // - 0 value transfers are allowed
    // ------------------------------------------------------------------------
    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
        balances[from] = safeSub(balances[from], tokens);
        allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
        balances[to] = safeAdd(balances[to], tokens);
        emit Transfer(from, to, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Returns the amount of tokens approved by the owner that can be
    // transferred to the spender's account
    // ------------------------------------------------------------------------
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
        return allowed[tokenOwner][spender];
    }


    // ------------------------------------------------------------------------
    // Token owner can approve for spender to transferFrom(...) tokens
    // from the token owner's account. The spender contract function
    // receiveApproval(...) is then executed
    // ------------------------------------------------------------------------
    function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
        return true;
    }


    // ------------------------------------------------------------------------
    // Don't accept ETH
    // ------------------------------------------------------------------------
    function () public payable {
        revert();
    }
}

References:

https://eips.ethereum.org/EIPS/eip-20

Run Solidity Code in Remix

Sergio Salanitri — Tue, 27 Jul 2021 12:22:57 +0000

Remix is a awersome Web Solidity Code Editor, with Remix do you not need install anything in your computer.
Using Remix you can edit, compile, deploy, test solidity contract show transaction logs, run contract methods, get github code, interact with JVM web blockchain, Metamask wallet (mainnet or testnet) and other features using Remix plugins.

File Explorer:
Show directoy tree with contracts codes. Keep in mind that this files save in local storage, however not shared between differents machine. I recommend create a github repo and load your code in it.

Command Bar:
Allow cahge betwwen the Remix features, such Solidity Compiler, Solidity Deploy & Run Transactions, Debug , plugins and general settings.

Solidity Editor:
Is the area where the developer write the solidity code. This to have code highlighting, intellisent, code lint and son on.

Transactions Logs:
Show the compiler, deploy, test, run contract functions, connect with blockchain provider etc.

General Settings:
Allow to develop set the editor settings.

Solidity Compiler:

The solidity compiler version must be compatible with #pragma definition in the code.

Where run the Compiler buttom, Remix compile the contract and in succesful case generate the ABI and the bycode associated with the contract.

The Application Binary Interface is the interface that expose the compiler contact. This is used to interact with the contract from out of chain.

Deploy the contract

Remix allow deploy the contract into JVM local blockchain, inject into external wallet such Metamask or external Web3 provider. Web3 is the protocol used to interact with external chain clients.

1- Deploy the contract in selected provider, in this case in JVM provider.
2- If the deploy is succesful Remix show button relationship with the contract public functions. The buttons color indicate if the operaction transaction save data (orange) or get data (blue) to or form chain.
3- We can view in transaction panel the information about the storage function.
4- Button to invoke retrieve function.
5- Beside we can view the transaction log from retrieve function.

Deploy the contract with Metamask

Metamask is a wallet implemented how Chrome extension, allow to developers connect to Ethereum blockchain.
In the case of Remix we can select Metamask provider using the Remix Enviroment combo box.
Previously you must install the Metamask extension and create a a wallet.

Now, we deploy and run the contract using Metamask.
Metamask allow connect to different blockchains, testnet , mainnet and other networks using RPC protocol. In this example with use the Rinkeby testnet network.
Before use it, we must transfer some fake Ethers to te wallet using th Rinkeby Faucet web page.

First in all you select one account address in your wallet.

Second , you use this address en Rinkey Faucet web page, follow the intructions to transfer some fake ethers to you address.

In this case when you run some transaction the Metamask extension popup a authorization message, if you click OK; the transation is send to Rinkeby network and several seconds later the transaction is confirmed.

If you enter to the Rinkeby account , you show that the account balance decrease en little ETH, this difference is due to the transaction gas fee.

References
Remix IDE: http://remix.ethereum.org/
Solidity ABI specification: https://bit.ly/3Ai3qof
Metamask: https://metamask.io/

Solidity in depth I

Sergio Salanitri — Sun, 27 Jun 2021 04:46:41 +0000

Solidity is the main smart contract language. This is used to develop smart contract that deploy in Ethereun network and others forked Ethereun blockchains.

But, what is a smart contract?

The smart contract is a code that run into de Ethereun Virtual Machine (EVM), deployed into the Ethereun Blockchaing and run in it. With the smart contract the developer can run transaction logic that perfome transferences, storage data, user validation and a lot of others thinks.

In this article I explain about simple contract development in Solidity Language.
In brief Solidity sintax is based in C++ and javascript but have to several unique sintaxis.
Not confuse the similar sintaxis to other language with how to run the solidity binaries code, is very different.

Well, enought talk and we write the code.

//SPDX-Licence-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;

/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Storage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) public {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retrieve() public view returns (uint256){
        return number;
    }
}

The firsts lines are the Licence and the solidity compiler version. The last line is very important to avoid some issue with different language features between compiler versions.

The keyword Contract indicate the contract inself.
Keep in mind that Solidity is a Object Oriented Language and the contract have to similar features that classes.

The next line uint256 number; indicate the variable declaration , Solidity es a strong typed language , in this case the variable number is a 256 bits int.

Declare functions in solidity we use the following sintax

function functioName(type2 arg1, type3 arg2...) <visibility scope> <other attributes> returns(type1, type2, type3...){
   //function body
}

In this contract there are two fuctions, the first save some integer in number variable and the second read this variable and return it.

Despite being a very simple code it apply several Solidity importants features.

The storage function save some integer in number variable, this integer save into the blockchain and needed run a blockchain transaction, this transaction spend gas (the cost of the transaction). Beside the function retrieve don't consume gas because only read the variable from blochchain (the atribute view allow this feature).

Do you view the attribute returns? How the name indicate is the return type, but unlike other language solidity allow retuns more that one variable in the same function!! :)

How we run this code?

The easiest way is using the Remix Web IDE (http://remix.ethereum.org/), in fact this example I get from this ide.

How we run this code in Remix Ide?

In the next article :), but while I propose that you try use the Remix IDE and research it.

See you!!