description: Tutorial on how to subscribe to smart contract events with Go.

Subscribing to Event Logs

First thing we need to do in order to subscribe to event logs is dial to a websocket enabled Ethereum client. Fortunately for us, Infura supports websockets.

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

The next step is to create a filter query. In this example we’ll be reading all events coming from the example contract that we’ve created in the previous lessons.

  1. contractAddress := common.HexToAddress("0x147B8eb97fD247D06C4006D269c90C1908Fb5D54")
  2. query := ethereum.FilterQuery{
  3.   Addresses: []common.Address{contractAddress},
  4. }

The way we’ll be receiving events is through a Go channel. Let’s create one with type of Log from the go-ethereum core/types package.

  1. logs := make(chan types.Log)

Now all we have to do is subscribe by calling SubscribeFilterLogs from the client, which takes in the query options and the output channel. This will return a subscription struct containing unsubscribe and error methods.

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

Finally all we have to do is setup an continous loop with a select statement to read in either new log events or the subscription error.

  1. for {
  2.   select {
  3.   case err := <-sub.Err():
  4.     log.Fatal(err)
  5.   case vLog := <-logs:
  6.     fmt.Println(vLog) // pointer to event log
  7.   }
  8. }

You’ll have to parse the log entries, which we’ll learn how to do in the next section.

Full code

Commands

  1. solc --abi Store.sol
  2. solc --bin Store.sol
  3. abigen --bin=Store_sol_Store.bin --abi=Store_sol_Store.abi --pkg=store --out=Store.go

Store.sol

  1. pragma solidity ^0.4.24;
  3. contract Store {
  4.   event ItemSet(bytes32 key, bytes32 value);
  6.   string public version;
  7.   mapping (bytes32 => bytes32) public items;
  9.   constructor(string _version) public {
  10.     version = _version;
  11.   }
  13.   function setItem(bytes32 key, bytes32 value) external {
  14.     items[key] = value;
  15.     emit ItemSet(key, value);
  16.   }
  17. }

event_subscribe.go

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "log"
  8.     "github.com/ethereum/go-ethereum"
  9.     "github.com/ethereum/go-ethereum/common"
  10.     "github.com/ethereum/go-ethereum/core/types"
  11.     "github.com/ethereum/go-ethereum/ethclient"
  12. )
  14. func main() {
  15.     client, err := ethclient.Dial("wss://rinkeby.infura.io/ws")
  16.     if err != nil {
  17.         log.Fatal(err)
  18.     }
  20.     contractAddress := common.HexToAddress("0x147B8eb97fD247D06C4006D269c90C1908Fb5D54")
  21.     query := ethereum.FilterQuery{
  22.         Addresses: []common.Address{contractAddress},
  23.     }
  25.     logs := make(chan types.Log)
  26.     sub, err := client.SubscribeFilterLogs(context.Background(), query, logs)
  27.     if err != nil {
  28.         log.Fatal(err)
  29.     }
  31.     for {
  32.         select {
  33.         case err := <-sub.Err():
  34.             log.Fatal(err)
  35.         case vLog := <-logs:
  36.             fmt.Println(vLog) // pointer to event log
  37.         }
  38.     }
  39. }
  1. $ solc --version
  2. 0.4.24+commit.e67f0147.Emscripten.clang