description: Tutorial on how to read ERC-20 Token smart contract events with Go.

Reading ERC-20 Token Event Logs

First create the ERC-20 smart contract interface for event logs as erc20.sol:

  1. pragma solidity ^0.4.24;
  3. contract ERC20 {
  4.     event Transfer(address indexed from, address indexed to, uint tokens);
  5.     event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
  6. }

Then use abigen to create the Go exchange package given the abi:

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

Now in our Go application let’s create the struct types matching the types of the ERC-20 event log signature:

  1. type LogTransfer struct {
  2.     From   common.Address
  3.     To     common.Address
  4.     Tokens *big.Int
  5. }
  7. type LogApproval struct {
  8.     TokenOwner common.Address
  9.     Spender    common.Address
  10.     Tokens     *big.Int
  11. }

Initialize the ethereum client:

  1. client, err := ethclient.Dial("https://mainnet.infura.io")
  2. if err != nil {
  3.   log.Fatal(err)
  4. }

Create a FilterQuery passing the ERC-20 smart contract address and the desired block range. We’ll be using the ZRX token for this example:

  1. // 0x Protocol (ZRX) token address
  2. contractAddress := common.HexToAddress("0xe41d2489571d322189246dafa5ebde1f4699f498")
  3. query := ethereum.FilterQuery{
  4.   FromBlock: big.NewInt(6383820),
  5.   ToBlock:   big.NewInt(6383840),
  6.   Addresses: []common.Address{
  7.     contractAddress,
  8.   },
  9. }

Query the logs with FilterLogs:

  1. logs, err := client.FilterLogs(context.Background(), query)
  2. if err != nil {
  3.   log.Fatal(err)
  4. }

Next we’ll parse the JSON abi which we’ll use unpack the raw log data later:

  1. contractAbi, err := abi.JSON(strings.NewReader(string(token.TokenABI)))
  2. if err != nil {
  3.   log.Fatal(err)
  4. }

In order to filter by certain log type, we need to figure out the keccak256 hash of each event log function signature. The event log function signature hash is always topic[0] as we’ll see soon. Here’s how to calculate the keccak256 hash using the go-ethereum crypto package:

  1. logTransferSig := []byte("Transfer(address,address,uint256)")
  2. LogApprovalSig := []byte("Approval(address,address,uint256)")
  3. logTransferSigHash := crypto.Keccak256Hash(logTransferSig)
  4. logApprovalSigHash := crypto.Keccak256Hash(LogApprovalSig)

Now we’ll iterate through all the logs and set up a switch statement to filter by event log type:

  1. for _, vLog := range logs {
  2.   fmt.Printf("Log Block Number: %d\n", vLog.BlockNumber)
  3.   fmt.Printf("Log Index: %d\n", vLog.Index)
  5.   switch vLog.Topics[0].Hex() {
  6.   case logTransferSigHash.Hex():
  7.     //
  8.   case logApprovalSigHash.Hex():
  9.     //
  10.   }
  11. }

Now to parse the Transfer event log we’ll use abi.Unpack to parse the raw log data into our log type struct. Unpack will not parse indexed event types because those are stored under topics, so for those we’ll have to parse separately as seen in the example below:

  1. fmt.Printf("Log Name: Transfer\n")
  3. var transferEvent LogTransfer
  5. err := contractAbi.Unpack(&transferEvent, "Transfer", vLog.Data)
  6. if err != nil {
  7.   log.Fatal(err)
  8. }
  10. transferEvent.From = common.HexToAddress(vLog.Topics[1].Hex())
  11. transferEvent.To = common.HexToAddress(vLog.Topics[2].Hex())
  13. fmt.Printf("From: %s\n", transferEvent.From.Hex())
  14. fmt.Printf("To: %s\n", transferEvent.To.Hex())
  15. fmt.Printf("Tokens: %s\n", transferEvent.Tokens.String())

Similarly for the Approval event log:

  1. fmt.Printf("Log Name: Approval\n")
  3. var approvalEvent LogApproval
  5. err := contractAbi.Unpack(&approvalEvent, "Approval", vLog.Data)
  6. if err != nil {
  7.   log.Fatal(err)
  8. }
  10. approvalEvent.TokenOwner = common.HexToAddress(vLog.Topics[1].Hex())
  11. approvalEvent.Spender = common.HexToAddress(vLog.Topics[2].Hex())
  13. fmt.Printf("Token Owner: %s\n", approvalEvent.TokenOwner.Hex())
  14. fmt.Printf("Spender: %s\n", approvalEvent.Spender.Hex())
  15. fmt.Printf("Tokens: %s\n", approvalEvent.Tokens.String())

Putting it all together and running it we’ll see the following output:

  1. Log Block Number: 6383829
  2. Log Index: 20
  3. Log Name: Transfer
  4. From: 0xd03dB9CF89A9b1f856a8E1650cFD78FAF2338eB2
  5. To: 0x924CD9b60F4173DCDd5254ddD38C4F9CAB68FE6b
  6. Tokens: 2804000000000000000000
  9. Log Block Number: 6383831
  10. Log Index: 62
  11. Log Name: Approval
  12. Token Owner: 0xDD3b9186Da521AbE707B48B8f805Fb3Cd5EEe0EE
  13. Spender: 0xCf67d7A481CEEca0a77f658991A00366FED558F7
  14. Tokens: 10000000000000000000000000000000000000000000000000000000000000000
  17. Log Block Number: 6383838
  18. Log Index: 13
  19. Log Name: Transfer
  20. From: 0xBA826fEc90CEFdf6706858E5FbaFcb27A290Fbe0
  21. To: 0x4aEE792A88eDDA29932254099b9d1e06D537883f
  22. Tokens: 2863452144424379687066

Compare the parsed log output to what’s on etherscan: https://etherscan.io/tx/0x0c3b6cf604275c7e44dc7db400428c1a39f33f0c6cbc19ff625f6057a5cb32c0#eventlog

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.     event Transfer(address indexed from, address indexed to, uint tokens);
  5.     event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
  6. }

event_read_erc20.go

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "log"
  7.     "math/big"
  8.     "strings"
  10.     token "./contracts_erc20" // for demo
  11.     "github.com/ethereum/go-ethereum"
  12.     "github.com/ethereum/go-ethereum/accounts/abi"
  13.     "github.com/ethereum/go-ethereum/common"
  14.     "github.com/ethereum/go-ethereum/crypto"
  15.     "github.com/ethereum/go-ethereum/ethclient"
  16. )
  18. // LogTransfer ..
  19. type LogTransfer struct {
  20.     From   common.Address
  21.     To     common.Address
  22.     Tokens *big.Int
  23. }
  25. // LogApproval ..
  26. type LogApproval struct {
  27.     TokenOwner common.Address
  28.     Spender    common.Address
  29.     Tokens     *big.Int
  30. }
  32. func main() {
  33.     client, err := ethclient.Dial("https://mainnet.infura.io")
  34.     if err != nil {
  35.         log.Fatal(err)
  36.     }
  38.     // 0x Protocol (ZRX) token address
  39.     contractAddress := common.HexToAddress("0xe41d2489571d322189246dafa5ebde1f4699f498")
  40.     query := ethereum.FilterQuery{
  41.         FromBlock: big.NewInt(6383820),
  42.         ToBlock:   big.NewInt(6383840),
  43.         Addresses: []common.Address{
  44.             contractAddress,
  45.         },
  46.     }
  48.     logs, err := client.FilterLogs(context.Background(), query)
  49.     if err != nil {
  50.         log.Fatal(err)
  51.     }
  53.     contractAbi, err := abi.JSON(strings.NewReader(string(token.TokenABI)))
  54.     if err != nil {
  55.         log.Fatal(err)
  56.     }
  58.     logTransferSig := []byte("Transfer(address,address,uint256)")
  59.     LogApprovalSig := []byte("Approval(address,address,uint256)")
  60.     logTransferSigHash := crypto.Keccak256Hash(logTransferSig)
  61.     logApprovalSigHash := crypto.Keccak256Hash(LogApprovalSig)
  63.     for _, vLog := range logs {
  64.         fmt.Printf("Log Block Number: %d\n", vLog.BlockNumber)
  65.         fmt.Printf("Log Index: %d\n", vLog.Index)
  67.         switch vLog.Topics[0].Hex() {
  68.         case logTransferSigHash.Hex():
  69.             fmt.Printf("Log Name: Transfer\n")
  71.             var transferEvent LogTransfer
  73.             err := contractAbi.Unpack(&transferEvent, "Transfer", vLog.Data)
  74.             if err != nil {
  75.                 log.Fatal(err)
  76.             }
  78.             transferEvent.From = common.HexToAddress(vLog.Topics[1].Hex())
  79.             transferEvent.To = common.HexToAddress(vLog.Topics[2].Hex())
  81.             fmt.Printf("From: %s\n", transferEvent.From.Hex())
  82.             fmt.Printf("To: %s\n", transferEvent.To.Hex())
  83.             fmt.Printf("Tokens: %s\n", transferEvent.Tokens.String())
  85.         case logApprovalSigHash.Hex():
  86.             fmt.Printf("Log Name: Approval\n")
  88.             var approvalEvent LogApproval
  90.             err := contractAbi.Unpack(&approvalEvent, "Approval", vLog.Data)
  91.             if err != nil {
  92.                 log.Fatal(err)
  93.             }
  95.             approvalEvent.TokenOwner = common.HexToAddress(vLog.Topics[1].Hex())
  96.             approvalEvent.Spender = common.HexToAddress(vLog.Topics[2].Hex())
  98.             fmt.Printf("Token Owner: %s\n", approvalEvent.TokenOwner.Hex())
  99.             fmt.Printf("Spender: %s\n", approvalEvent.Spender.Hex())
  100.             fmt.Printf("Tokens: %s\n", approvalEvent.Tokens.String())
  101.         }
  103.         fmt.Printf("\n\n")
  104.     }
  105. }

solc version used for these examples

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