Tokens represent digital assets and have value, but not all conform to specific specifications.

Erc20-based currencies are more interchangeable and work equally well on Dapps.

The new standard could make tokens more compatible and allow for other features, including vote tokenization. The operation is more like a vote operation

Token holders have full control over the assets, and erC20-compliant tokens can track how many tokens anyone has at any one time. Eth contract based sub-currency, so easy to implement. You have to transfer it yourself.

Standardization is very beneficial, meaning that these assets can be used across different platforms and projects that would otherwise only be used in specific situations.

The following standards allow markup apis to be implemented in smart contracts. The standard provides basic functionality for transferring tokens and allows tokens to be approved so that they can be used by another online third party.

Note: The caller must handle returns (bool success) that return false. The caller must never assume that a return of false does not exist.

Returns the symbol of the token, such as HIX.

Optional – This method can be used to improve availability, but interfaces and other contracts cannot expect these values to exist.

function symbol(a) constant returns (string symbol)Copy the code

Returns the total supply of tokens.

function totalSupply(a) constant returns (uint256 totalSupply)Copy the code

Transfer _value token quantity to address _to, and Transfer event must be triggered. If the _from account balance does not have enough tokens to spend, the function should be thrown.

The token contract that creates the new token should set the _FROM address to 0x0 when the token is created to trigger the transport event.

Note that the transfer of a value of 0 must be treated as a normal transfer and trigger the transfer event.

function transfer(address _to, uint256 _value) returns (bool success)Copy the code

Allow _spender to retrieve your account multiple times, up to a _value amount. If this function is called again, it overrides the current margin with _value.

Note: To prevent vector attacks, the client needs to make sure that the user interfaces are created in such a way that they are set to 0 and then set to another value for the same spender. Although the contract itself should not be enforced, backward compatibility with previously deployed contract compatibility is allowed

function approve(address _spender, uint256 _value) returns (bool success)Copy the code

Must be triggered after any successful call to approve(address _spender, uint256 _value).

event Approval(address indexed _owner, address indexed _spender, uint256 _value)Copy the code

• Github.com/ConsenSys/T…
• Github.com/OpenZeppeli…

The following is a snippet of the token contract to demonstrate how token contracts maintain token balances in Ethereum accounts

contract TokenContractFragment {

     Balances saves the balance of the address
     mapping(address => uint256) balances;

     // The account owner approves the transfer of the amount to another account
     mapping(address => mapping (address => uint256)) allowed;

      // What is the balance of a particular account?
      function balanceOf(address _owner) constant returns (uint256 balance) {
          return balances[_owner]; // Take the value from the array
      }

      // Transfer the balance from the owner account to another account
      function transfer(address _to, uint256 _amount) returns (bool success) {
          // Determine the condition sender balance >= value to be sent Value to be sent >0 Receiver balance + value to be sent > receiver balance
          if (balances[msg.sender] >= _amount 
              && _amount > 0
              && balances[_to] + _amount > balances[_to]) {
              balances[msg.sender] -= _amount;   // The sender's balance decreases
              balances[_to] += _amount;         // The recipient's balance increases
              return true;
         } else {
              return false; }}// Send _value number of tokens from address _from to address _to
      // The transferFrom method is used to extract the workflow that allows the contract to send tokens in your name, such as "deposit" to the contract address and/or charge in sub-currencies; This command should fail unless the _FROM account intentionally authorizes the sender of the message through some mechanism; We propose these standardized apis for approval:
      function transferFrom( address _from, address _to, uint256 _amount ) returns (bool success) {
          // Same validation rule as above
          if (balances[_from] >= _amount
              && allowed[_from][msg.sender] >= _amount
              && _amount > 0
              && balances[_to] + _amount > balances[_to]) {
              balances[_from] -= _amount;
              allowed[_from][msg.sender] -= _amount; // Reduce the number of senders' approvals
              balances[_to] += _amount;
              return true;
         } else {
             return false; }}// Allow _spender to exit your account multiple times, up to the _value amount. If this function is called again, it overrides the current margin with _value.
      function approve(address _spender, uint256 _amount) returns (bool success) {
          allowed[msg.sender][_spender] = _amount; // Overwrite the current margin
          return true; }}Copy the code

If 0 x1111111111111111111111111111111111111111 want to transfer to 0 x2222222222222222222222222222222222222222 10 units, and then zero x1111111111111111111 11111111111111111 will execute the following function

tokenContract.transfer(0x2222222222222222222222222222222222222222.10)Copy the code

Transfer of token contracts (…) Method changes the information in the balances structure

balances[0x1111111111111111111111111111111111111111] = 90
balances[0x2222222222222222222222222222222222222222] = 210Copy the code

balanceOf(…) The call returns the following information

tokenContract.balanceOf(0x1111111111111111111111111111111111111111) will return90
tokenContract.balanceOf(0x2222222222222222222222222222222222222222) will return210Copy the code

Here is a sample token contract with a fixed supply of 1,000,000 units initially allocated to the contract owner:

pragma solidity ^0.48.;

  // ----------------------------------------------------------------------------------------------
  // Sample fixed supply token contract
  // Enjoy. (c) BokkyPooBah 2017. The MIT Licence.
  // ----------------------------------------------------------------------------------------------

   // ERC Token Standard #20 Interface
  // https://github.com/ethereum/EIPs/issues/20
  contract ERC20Interface {
      // Get total support
      function totalSupply(a) constant returns (uint256 totalSupply);

      // Get the balance of other addresses
      function balanceOf(address _owner) constant returns (uint256 balance);

      // Send tokens to other addresses
      function transfer(address _to, uint256 _value) returns (bool success);

      // Send the balance from one address to another
      function transferFrom(address _from, address _to, uint256 _value) returns (bool success);

      // Allows _spender to transfer the balance of _value from your account. Multiple calls overwrite the available amount. Some DEX functions require this feature
      function approve(address _spender, uint256 _value) returns (bool success);

      // Returns the amount of balance that _spender still allows to exit from _owner
      function allowance(address _owner, address _spender) constant returns (uint256 remaining);

      // The token transfer is completed
      event Transfer(address indexed _from, address indexed _to, uint256 _value);

      // trigger after approve(address _spender, uint256 _value) is called
      event Approval(address indexed _owner, address indexed _spender, uint256 _value);
  }

   // Inherits the interface instance
   contract FixedSupplyToken is ERC20Interface {
      string public constant symbol = "FIXED"; / / unit
      string public constant name = "Example Fixed Supply Token"; / / name
      uint8 public constant decimals = 18; // The number of decimal places
      uint256 _totalSupply = 1000000; // Total number of issues

      // Owner of the smart contract
      address public owner;

      // The balance of each account
      mapping(address => uint256) balances;

      // The account owner approves the transfer of the amount to another account. From the description above, we can learn that the account is allowed[an account where money is transferred]
      mapping(address => mapping (address => uint256)) allowed;

      // a method that can only be called by the owner of the smart contract
      modifier onlyOwner() {
          if(msg.sender ! = owner) {throw;
          }
          _;
      }

      // constructor
      function FixedSupplyToken(a) {
          owner = msg.sender;
          balances[owner] = _totalSupply;
      }

      function totalSupply(a) constant returns (uint256 totalSupply) {
          totalSupply = _totalSupply;
      }

      // The balance of a specific account
      function balanceOf(address _owner) constant returns (uint256 balance) {
          return balances[_owner];
      }

      // Transfer the balance to another account
      function transfer(address _to, uint256 _amount) returns (bool success) {
          if (balances[msg.sender] >= _amount 
              && _amount > 0
              && balances[_to] + _amount > balances[_to]) {
              balances[msg.sender] -= _amount;
              balances[_to] += _amount;
              Transfer(msg.sender, _to, _amount);
              return true;
          } else {
              return false; }}// Transfer from one account to another, as long as there is a balance that can be transferred
      function transferFrom( address _from, address _to, uint256 _amount ) returns (bool success) {
          if (balances[_from] >= _amount
              && allowed[_from][msg.sender] >= _amount
              && _amount > 0
              && balances[_to] + _amount > balances[_to]) {
              balances[_from] -= _amount;
              allowed[_from][msg.sender] -= _amount;
              balances[_to] += _amount;
              Transfer(_from, _to, _amount);
              return true;
          } else {
              return false; }}// Allows an account to transfer balances from the current user to that account, overwritten by multiple calls
      function approve(address _spender, uint256 _amount) returns (bool success) {
          allowed[msg.sender][_spender] = _amount;
          Approval(msg.sender, _spender, _amount);
          return true;
      }

      // Return the number of balances allowed to transfer
      function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
          returnallowed[_owner][_spender]; }}Copy the code

Note that in the last example, the allowed parameter in the second dimension is the number of transfers by the caller, while in the beginning example, the number of receivers.