Write a token-based Ethereum smart contract

For this particular project, I use a smart contract compliant to ERC-20 because this standard is widely adopted by a majority of tokens on Ethereum, and rather simple to implement.

So what does it mean ERC-20 contract ? ERC-20 is a proposal of standards to create and exchange tokens on Ethereum network. You can think of ERC-20 similar to an interface or a blueprint which propose a set of functions and events. Any smart contracts that implement ERC-20 standards are ERC-20 contracts, or precisely ERC-20 compliant. ERC-20 is not the only standard that exists and of course anyone can propose set of standards for the type of smart contract they are working on.

What are advantages of ERC-20 compliant ? It allows cryptocurrencies or digital assets to be traded more easily on Ethereum. Take a look at the wallet of an average cryptocurrency/token trader/investor, there would certainly be more than two currencies/tokens/digital assets(*) at any moment. If there aren’t any common standards, the digital wallet must implement different function calls to talk to each of underlying smart contracts which operate trades upon corresponding tokens/assets. A common standard such as ERC-20 ensures that Ethereum wallets or DApps only need to implement once a set of function calls in order to interact with smart contracts of similar nature.

The proposal is only for tokens within Ethereum network. There exists no such mechanism across different blockchains because of their distinctive nature.

What comprises ERC-20 ? An ERC-20 compliant must implements the interface below:

// ----------------------------------------------------------------------------

// ERC Token Standard #20 Interface

// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md

// ----------------------------------------------------------------------------

contract ERC20Interface {

function totalSupply() public view returns (uint);

function balanceOf(address tokenOwner) public view returns (uint balance);

function allowance(address tokenOwner, address spender) public view 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);

}

• • totalSupply() function returns the total amount of tokens exist on the contract at the moment of query.

• • balanceOf() function returns amount of tokens owned by an account at the moment of query.

• • allowance() function returns amount of tokens authorized to be withdrawn from a holder’s account by somebody acting on his behalf.

• • approve() function allows a holder of coins to grant another account the right to withdrawal coins from his pocket within a specific amount. This function emits Approval event when execution succeeds.

• • transfer() function allows to transfer tokens from one’s pocket to another’s. This function emits Transfer event when execution succeeds.

• transferFrom() function allows a representative to transfer coins (which he does not own but has been granted the right to spend), to another account.

You are not bound to any specific implementations of these functions, as long as you respect their signatures. It means that you are completely free to design your ERC-20 compliant to fit your business rules. For example, you can have the total supply of tokens fixed upon contract deployment, or varied by time. Or you can set a complex mechanism to approve a spender of your coins.

If you want to understand thoroughly ERC-20, take a look at the post by Jim McDonald which offers excellent explications. Link to resources at the end of the article.

6/ Add holder: Only a holder can add another holder to contract.

7/ Remove holder: Only contract owner can remove a holder from a contract. Upon removal, the holder to be remove must have balance of naught (0), or else the transaction will fail and prompt you to transfer all tokens owned by this holder to another address.

8/ Remove appointee: Only a holder can remove his representative. Upon removal, allowance of the appointee is set to 0 instead of removing him from _allowance mapping. This is because the data structure used to map holders and their appointees is of type mapping (key-value pair), and in Solidity, any elements are presumed to exist in a mapping with default value if not assigned.

The additional rules do not make my contract less ERC-20 compliant, and add more specific rules tailored to the contract.

You can see that Solidity employs rather simple syntax. Coming from such a rich language as C#, I find Solidity lacks a lot of features. However, the language is dedicated to writing of smart contracts and thus, keeping it simple, correct and concise is more important than being full fledged. It is also recommended that you should break your long and bulky contract into smaller ones, and keep function calls simple and granular in order to easily control over gas consumed.

I encourage you to deep dive into specifications of Solidity and smart contract.

Once having finished writing your contract, press F5 on Visual Studio Code to compile it. This will create a folder named bin inside your contract’s root folder. The bin folder contains the bytecode of your smart contract which will be used to deploy to EVM, and abi file which describe contract’s properties in JSON. The abi file is necessary to deserialize the deployed contract into JavaScript or C# object, which is then used to interact with EVM though remote procedure calls.

Remix is a online editor for Solidity smart contract which also offers testing tools. Just go to https://remix.ethereum.org/ , paste in your contract, compile and choose a method to deploy onto embedded devchain which is preconfigured with several accounts with fake Ether. You can use these accounts to test token transactions.

At this point our contract is ready to be deployed to ethereum blockchain. Using Mist or any ethereum clients you can easily deploy it without touching a line of code. Tokens can be traded with any wallets support ERC20 contract, which means you can already crowdfund your business using the ICO we have created. However in the part 3 of tutorial I will show you how to programmatically deploy smart contracts using Nethereum library. Please refer to part 3.