description: Tutorial on how to query an ERC20 token smart contract with Go.

Querying an ERC20 Token Smart Contract

First create an ERC20 smart contract interface. This is just a contract with the function definitions of the functions that you can call.

  1. pragma solidity ^0.4.24;
  3. contract ERC20 {
  4.     string public constant name = "";
  5.     string public constant symbol = "";
  6.     uint8 public constant decimals = 0;
  8.     function totalSupply() public constant returns (uint);
  9.     function balanceOf(address tokenOwner) public constant returns (uint balance);
  10.     function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
  11.     function transfer(address to, uint tokens) public returns (bool success);
  12.     function approve(address spender, uint tokens) public returns (bool success);
  13.     function transferFrom(address from, address to, uint tokens) public returns (bool success);
  15.     event Transfer(address indexed from, address indexed to, uint tokens);
  16.     event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
  17. }

Then compile the smart contract to the JSON ABI, and create a Go token package out of the ABI using abigen.

  1. solc --abi erc20.sol
  2. abigen --abi=erc20_sol_ERC20.abi --pkg=token --out=erc20.go

Assuming we already have Ethereum client set up as usual, we can now import the new token package into our application and instantiate it. In this example we’ll be using the Golem token.

  1. tokenAddress := common.HexToAddress("0xa74476443119A942dE498590Fe1f2454d7D4aC0d")
  2. instance, err := token.NewToken(tokenAddress, client)
  3. if err != nil {
  4.   log.Fatal(err)
  5. }

We may now call any ERC20 method that we like. For example, we can query the token balance of a user.

  1. address := common.HexToAddress("0x0536806df512d6cdde913cf95c9886f65b1d3462")
  2. bal, err := instance.BalanceOf(&bind.CallOpts{}, address)
  3. if err != nil {
  4.   log.Fatal(err)
  5. }
  7. fmt.Printf("wei: %s\n", bal) // "wei: 74605500647408739782407023"

We can also read the public variables of the ERC20 smart contract.

  1. name, err := instance.Name(&bind.CallOpts{})
  2. if err != nil {
  3.   log.Fatal(err)
  4. }
  6. symbol, err := instance.Symbol(&bind.CallOpts{})
  7. if err != nil {
  8.   log.Fatal(err)
  9. }
  11. decimals, err := instance.Decimals(&bind.CallOpts{})
  12. if err != nil {
  13.   log.Fatal(err)
  14. }
  16. fmt.Printf("name: %s\n", name)         // "name: Golem Network"
  17. fmt.Printf("symbol: %s\n", symbol)     // "symbol: GNT"
  18. fmt.Printf("decimals: %v\n", decimals) // "decimals: 18"

We can do some simple math to convert the balance into a human readable decimal format.

  1. fbal := new(big.Float)
  2. fbal.SetString(bal.String())
  3. value := new(big.Float).Quo(fbal, big.NewFloat(math.Pow10(int(decimals))))
  5. fmt.Printf("balance: %f", value) // "balance: 74605500.647409"

See the same information on etherscan: https://etherscan.io/token/0xa74476443119a942de498590fe1f2454d7d4ac0d?a=0x0536806df512d6cdde913cf95c9886f65b1d3462

Full code

Commands

  1. solc --abi erc20.sol
  2. abigen --abi=erc20_sol_ERC20.abi --pkg=token --out=erc20.go

erc20.sol

  1. pragma solidity ^0.4.24;
  3. contract ERC20 {
  4.     string public constant name = "";
  5.     string public constant symbol = "";
  6.     uint8 public constant decimals = 0;
  8.     function totalSupply() public constant returns (uint);
  9.     function balanceOf(address tokenOwner) public constant returns (uint balance);
  10.     function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
  11.     function transfer(address to, uint tokens) public returns (bool success);
  12.     function approve(address spender, uint tokens) public returns (bool success);
  13.     function transferFrom(address from, address to, uint tokens) public returns (bool success);
  15.     event Transfer(address indexed from, address indexed to, uint tokens);
  16.     event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
  17. }

contract_read_erc20.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "log"
  6.     "math"
  7.     "math/big"
  9.     "github.com/ethereum/go-ethereum/accounts/abi/bind"
  10.     "github.com/ethereum/go-ethereum/common"
  11.     "github.com/ethereum/go-ethereum/ethclient"
  13.     token "./contracts_erc20" // for demo
  14. )
  16. func main() {
  17.     client, err := ethclient.Dial("https://mainnet.infura.io")
  18.     if err != nil {
  19.         log.Fatal(err)
  20.     }
  22.     // Golem (GNT) Address
  23.     tokenAddress := common.HexToAddress("0xa74476443119A942dE498590Fe1f2454d7D4aC0d")
  24.     instance, err := token.NewToken(tokenAddress, client)
  25.     if err != nil {
  26.         log.Fatal(err)
  27.     }
  29.     address := common.HexToAddress("0x0536806df512d6cdde913cf95c9886f65b1d3462")
  30.     bal, err := instance.BalanceOf(&bind.CallOpts{}, address)
  31.     if err != nil {
  32.         log.Fatal(err)
  33.     }
  35.     name, err := instance.Name(&bind.CallOpts{})
  36.     if err != nil {
  37.         log.Fatal(err)
  38.     }
  40.     symbol, err := instance.Symbol(&bind.CallOpts{})
  41.     if err != nil {
  42.         log.Fatal(err)
  43.     }
  45.     decimals, err := instance.Decimals(&bind.CallOpts{})
  46.     if err != nil {
  47.         log.Fatal(err)
  48.     }
  50.     fmt.Printf("name: %s\n", name)         // "name: Golem Network"
  51.     fmt.Printf("symbol: %s\n", symbol)     // "symbol: GNT"
  52.     fmt.Printf("decimals: %v\n", decimals) // "decimals: 18"
  54.     fmt.Printf("wei: %s\n", bal) // "wei: 74605500647408739782407023"
  56.     fbal := new(big.Float)
  57.     fbal.SetString(bal.String())
  58.     value := new(big.Float).Quo(fbal, big.NewFloat(math.Pow10(int(decimals))))
  60.     fmt.Printf("balance: %f", value) // "balance: 74605500.647409"
  61. }

solc version used for these examples

  1. $ solc --version
  2. 0.4.24+commit.e67f0147.Emscripten.clang