{"id":2371,"date":"2020-01-09T11:28:25","date_gmt":"2020-01-09T10:28:25","guid":{"rendered":"https:\/\/www.codemotion.com\/magazine\/uncategorized\/simple-contract-solidity-blockchain\/"},"modified":"2021-12-23T14:15:37","modified_gmt":"2021-12-23T13:15:37","slug":"simple-contract-solidity-blockchain","status":"publish","type":"post","link":"https:\/\/www.codemotion.com\/magazine\/backend\/blockchain\/simple-contract-solidity-blockchain\/","title":{"rendered":"A simple contract in Solidity"},"content":{"rendered":"

After choosing the best IDE<\/span> to develop our first smart contract, we will now write some actual code.<\/p>\n

This is part three of a series on how to create an ERC-20 token. If you want to begin from scratch, please read part one<\/a><\/u> and part two<\/a><\/u> of this series (part four<\/a> and part five<\/a> are right here)<\/a>.<\/p>\n

Using Ethereum Studio<\/strong>, we began using the \u2018Hello World<\/span>\u2019 template to understand the basics of Solidity. This is the \u2018Hello World<\/span>\u2019 template:<\/p>\n

pragma solidity ^0.5.10;
contract HelloWorld<\/span> {

   string public message;

\u00a0\u00a0\u00a0constructor(string memory initMessage) public {
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0message = initMessage;
   }

   function update(string memory newMessage) public {
      message = newMessage;
      }
}<\/pre>\n
This says that the smart contract HelloWorld<\/span> initializes a message that is passed as a parameter and which can be updated using the update<\/em> function. Please remember that the newMessage<\/em> variable<\/span> will be the message <\/span><\/em>variable for the most updated block, but one can view all message <\/span><\/em>variables in previous blocks: this is known as a State Variable<\/span><\/strong>. Every variable<\/span> in a smart contract is a variable<\/span> in the block it gets executed into. All variables<\/span> in a given block compose the State <\/strong>of the blockchain, along with all the \u2018normal\u2019 transactions.<\/p>\n
Functions<\/strong> are the same as in every other programming language<\/span>, and can accept parameters and return variables<\/span>.<\/p>\n
We will now explore the development of a simple contract for implementing the simplest form of cryptocurrency. It allows the creation of new coins (minting<\/strong>), and sending them to addresses belonging to the same blockchain (transactions between assets in two different blockchain are possible, but require an extra layer<\/strong> that will not be discussed in this series).<\/p>\n
In order to do implement this form, we can edit the current situation by pasting this code and renaming the file to ExampleCoin.sol:<\/p>\n
pragma solidity<\/strong> >=0.5.0 <0.7.0;
contract<\/strong> ExampleCoin {
   address public minter;

   mapping (address => uint) public balances;
   
   event Sent(address from, address to, uint amount);

   constructor() public {
      minter = msg.sender;
      }
   function mint(address receiver, uint amount) public {
      require(msg.sender == minter);
      require(amount < 1e60);
      balances[receiver] += amount;
   }

   function send(address received, uint amount) public {
      require(amount <= balances[msg.sender], \"Insufficient balance.\");
      balances[msg.sender] -= amount;
      balances[receiver] += amount;
      emit Sent(msg.sender, receiver, amount);
   }
}<\/pre>\n
The contract above is very simple: it creates an ExampleCoin <\/em>token (also referred to as subcurrency <\/em>in Ethereum Studio) by initializing a coin minter (with the public constructor), <\/em>i.e., an address that can create new coins. This is also the address of the contract creator, so only the creator can mint new coins (see the require(msg.sender == minter) <\/em>instruction). This contract also models the mapping<\/em> of every address with its balance, and the function send<\/em> that simply checks the feasibility of the transaction. If the sender has less balance that they want to send, the contract will return an Insufficient balance<\/em> statement<\/span> and the transaction will not be completed. If the transaction is feasible, the function will emit <\/em>a send <\/em>event – a declaration for the broadcast of the transactions. Ethereum clients<\/span> (wallets or decentralized apps on the web) can listen to these events emitted on the blockchain without much cost. As soon as the event is emitted, the listener receives the arguments from<\/em>, to<\/em>, and amount<\/em>, which makes it possible to track transactions.<\/p>\n
Keep in mind: to approve any transaction, the client<\/span> (wallet or decentralized app on the web) must be synced with the State of the blockchain<\/strong>, i.e., it must know what the most recent state of all the variables<\/span> in the blockchain is. A smart contract executed offline will not verify the requirements of the transactions until it\u2019s back online and fully synced with the blockchain.<\/p>\n
The minter <\/em>and every address<\/em> mapped are State Variables<\/span>. Specifically, this mapping can be thought of as hash tables, virtually initialized such that every possible key exists from the start and is mapped to a value whose byte<\/span>-representation is all zeros.<\/p>\n
It\u2019s impossible to get a list of all of a mapping’s keys, or a list of all values, so it\u2019s good practice<\/span> to either record what you added to the mapping (if it\u2019s useful for other functions), or to keep a list of all the changes recorded by the contract.<\/p>\n
To get the balance of an address, the balances <\/em>function can be used at any time:<\/p>\n
function balances(address _account) external view returns (uint) {
   return balances[_account];
}<\/pre>\n
The main ExampleCoin.sol file is now complete (for the moment), but to make this contract usable, we need to give it the capacity for interaction. The .sol file is intended to be the backend logic of the contract, but there\u2019s also a frontend logic that needs to be implemented. This logic can be developed with the Web3<\/strong> technology stack, and that will be the main focus of the next chapter in this series.<\/p>\n