description: Tutorial on how to read the 0x Protocol smart contract event logs with Go.

Reading 0x Protocol Event Logs

To read 0x Protocol event logs we must first compile the solidity smart contract to a Go package.

Install solc version 0.4.11

  1. npm i -g solc@0.4.11

Create the 0x protocol exchange smart contract interface for event logs as Exchange.sol:

  1. pragma solidity 0.4.11;
  3. contract Exchange {
  4.     event LogFill(
  5.         address indexed maker,
  6.         address taker,
  7.         address indexed feeRecipient,
  8.         address makerToken,
  9.         address takerToken,
  10.         uint filledMakerTokenAmount,
  11.         uint filledTakerTokenAmount,
  12.         uint paidMakerFee,
  13.         uint paidTakerFee,
  14.         bytes32 indexed tokens, // keccak256(makerToken, takerToken), allows subscribing to a token pair
  15.         bytes32 orderHash
  16.     );
  18.     event LogCancel(
  19.         address indexed maker,
  20.         address indexed feeRecipient,
  21.         address makerToken,
  22.         address takerToken,
  23.         uint cancelledMakerTokenAmount,
  24.         uint cancelledTakerTokenAmount,
  25.         bytes32 indexed tokens,
  26.         bytes32 orderHash
  27.     );
  29.     event LogError(uint8 indexed errorId, bytes32 indexed orderHash);
  30. }

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

  1. solc --abi Exchange.sol
  2. abigen --abi="Exchange.sol:Exchange.abi" --pkg=exchange --out=Exchange.go

Now in our Go application let’s create the struct types matching the types of the 0xProtocol event log signature:

  1. type LogFill struct {
  2.     Maker                  common.Address
  3.     Taker                  common.Address
  4.     FeeRecipient           common.Address
  5.     MakerToken             common.Address
  6.     TakerToken             common.Address
  7.     FilledMakerTokenAmount *big.Int
  8.     FilledTakerTokenAmount *big.Int
  9.     PaidMakerFee           *big.Int
  10.     PaidTakerFee           *big.Int
  11.     Tokens                 [32]byte
  12.     OrderHash              [32]byte
  13. }
  15. type LogCancel struct {
  16.     Maker                     common.Address
  17.     FeeRecipient              common.Address
  18.     MakerToken                common.Address
  19.     TakerToken                common.Address
  20.     CancelledMakerTokenAmount *big.Int
  21.     CancelledTakerTokenAmount *big.Int
  22.     Tokens                    [32]byte
  23.     OrderHash                 [32]byte
  24. }
  26. type LogError struct {
  27.     ErrorID   uint8
  28.     OrderHash [32]byte
  29. }

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 0x Protocol smart contract address and the desired block range:

  1. // 0x Protocol Exchange smart contract address
  2. contractAddress := common.HexToAddress("0x12459C951127e0c374FF9105DdA097662A027093")
  3. query := ethereum.FilterQuery{
  4.   FromBlock: big.NewInt(6383482),
  5.   ToBlock:   big.NewInt(6383488),
  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 to unpack the raw log data later:

  1. contractAbi, err := abi.JSON(strings.NewReader(string(exchange.ExchangeABI)))
  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:

  1. // NOTE: keccak256("LogFill(address,address,address,address,address,uint256,uint256,uint256,uint256,bytes32,bytes32)")
  2. logFillEvent := common.HexToHash("0d0b9391970d9a25552f37d436d2aae2925e2bfe1b2a923754bada030c498cb3")
  4. // NOTE: keccak256("LogCancel(address,address,address,address,uint256,uint256,bytes32,bytes32)")
  5. logCancelEvent := common.HexToHash("67d66f160bc93d925d05dae1794c90d2d6d6688b29b84ff069398a9b04587131")
  7. // NOTE: keccak256("LogError(uint8,bytes32)")
  8. logErrorEvent := common.HexToHash("36d86c59e00bd73dc19ba3adfe068e4b64ac7e92be35546adeddf1b956a87e90")

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 logFillEvent.Hex():
  7.     //
  8.   case logCancelEvent.Hex():
  9.     //
  10.   case logErrorEvent.Hex():
  11.     //
  12.   }
  13. }

Now to parse LogFill 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: LogFill\n")
  3. var fillEvent LogFill
  5. err := contractAbi.Unpack(&fillEvent, "LogFill", vLog.Data)
  6. if err != nil {
  7.   log.Fatal(err)
  8. }
  10. fillEvent.Maker = common.HexToAddress(vLog.Topics[1].Hex())
  11. fillEvent.FeeRecipient = common.HexToAddress(vLog.Topics[2].Hex())
  12. fillEvent.Tokens = vLog.Topics[3]
  14. fmt.Printf("Maker: %s\n", fillEvent.Maker.Hex())
  15. fmt.Printf("Taker: %s\n", fillEvent.Taker.Hex())
  16. fmt.Printf("Fee Recipient: %s\n", fillEvent.FeeRecipient.Hex())
  17. fmt.Printf("Maker Token: %s\n", fillEvent.MakerToken.Hex())
  18. fmt.Printf("Taker Token: %s\n", fillEvent.TakerToken.Hex())
  19. fmt.Printf("Filled Maker Token Amount: %s\n", fillEvent.FilledMakerTokenAmount.String())
  20. fmt.Printf("Filled Taker Token Amount: %s\n", fillEvent.FilledTakerTokenAmount.String())
  21. fmt.Printf("Paid Maker Fee: %s\n", fillEvent.PaidMakerFee.String())
  22. fmt.Printf("Paid Taker Fee: %s\n", fillEvent.PaidTakerFee.String())
  23. fmt.Printf("Tokens: %s\n", hexutil.Encode(fillEvent.Tokens[:]))
  24. fmt.Printf("Order Hash: %s\n", hexutil.Encode(fillEvent.OrderHash[:]))

Similarly for LogCancel:

  1. fmt.Printf("Log Name: LogCancel\n")
  3. var cancelEvent LogCancel
  5. err := contractAbi.Unpack(&cancelEvent, "LogCancel", vLog.Data)
  6. if err != nil {
  7.   log.Fatal(err)
  8. }
  10. cancelEvent.Maker = common.HexToAddress(vLog.Topics[1].Hex())
  11. cancelEvent.FeeRecipient = common.HexToAddress(vLog.Topics[2].Hex())
  12. cancelEvent.Tokens = vLog.Topics[3]
  14. fmt.Printf("Maker: %s\n", cancelEvent.Maker.Hex())
  15. fmt.Printf("Fee Recipient: %s\n", cancelEvent.FeeRecipient.Hex())
  16. fmt.Printf("Maker Token: %s\n", cancelEvent.MakerToken.Hex())
  17. fmt.Printf("Taker Token: %s\n", cancelEvent.TakerToken.Hex())
  18. fmt.Printf("Cancelled Maker Token Amount: %s\n", cancelEvent.CancelledMakerTokenAmount.String())
  19. fmt.Printf("Cancelled Taker Token Amount: %s\n", cancelEvent.CancelledTakerTokenAmount.String())
  20. fmt.Printf("Tokens: %s\n", hexutil.Encode(cancelEvent.Tokens[:]))
  21. fmt.Printf("Order Hash: %s\n", hexutil.Encode(cancelEvent.OrderHash[:]))

And finally for LogError:

  1. fmt.Printf("Log Name: LogError\n")
  3. errorID, err := strconv.ParseInt(vLog.Topics[1].Hex(), 16, 64)
  4. if err != nil {
  5.   log.Fatal(err)
  6. }
  8. errorEvent := &LogError{
  9.   ErrorID:   uint8(errorID),
  10.   OrderHash: vLog.Topics[2],
  11. }
  13. fmt.Printf("Error ID: %d\n", errorEvent.ErrorID)
  14. fmt.Printf("Order Hash: %s\n", hexutil.Encode(errorEvent.OrderHash[:]))

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

  1. Log Block Number: 6383482
  2. Log Index: 35
  3. Log Name: LogFill
  4. Maker: 0x8dd688660ec0BaBD0B8a2f2DE3232645F73cC5eb
  5. Taker: 0xe269E891A2Ec8585a378882fFA531141205e92E9
  6. Fee Recipient: 0xe269E891A2Ec8585a378882fFA531141205e92E9
  7. Maker Token: 0xD7732e3783b0047aa251928960063f863AD022D8
  8. Taker Token: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
  9. Filled Maker Token Amount: 240000000000000000000000
  10. Filled Taker Token Amount: 6930282000000000000
  11. Paid Maker Fee: 0
  12. Paid Taker Fee: 0
  13. Tokens: 0xf08499c9e419ea8c08c4b991f88632593fb36baf4124c62758acb21898711088
  14. Order Hash: 0x306a9a7ecbd9446559a2c650b4cfc16d1fb615aa2b3f4f63078da6d021268440
  17. Log Block Number: 6383482
  18. Log Index: 38
  19. Log Name: LogFill
  20. Maker: 0x04aa059b2e31B5898fAB5aB24761e67E8a196AB8
  21. Taker: 0xe269E891A2Ec8585a378882fFA531141205e92E9
  22. Fee Recipient: 0xe269E891A2Ec8585a378882fFA531141205e92E9
  23. Maker Token: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
  24. Taker Token: 0xD7732e3783b0047aa251928960063f863AD022D8
  25. Filled Maker Token Amount: 6941718000000000000
  26. Filled Taker Token Amount: 240000000000000000000000
  27. Paid Maker Fee: 0
  28. Paid Taker Fee: 0
  29. Tokens: 0x97ef123f2b566f36ab1e6f5d462a8079fbe34fa667b4eae67194b3f9cce60f2a
  30. Order Hash: 0xac270e88ce27b6bb78ee5b68ebaef666a77195020a6ab8922834f07bc9e0d524
  33. Log Block Number: 6383488
  34. Log Index: 43
  35. Log Name: LogCancel
  36. Maker: 0x0004E79C978B95974dCa16F56B516bE0c50CC652
  37. Fee Recipient: 0xA258b39954ceF5cB142fd567A46cDdB31a670124
  38. Maker Token: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
  39. Taker Token: 0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359
  40. Cancelled Maker Token Amount: 30000000000000000000
  41. Cancelled Taker Token Amount: 7274848425000000000000
  42. Tokens: 0x9dd48110dcc444fdc242510c09bbbbe21a5975cac061d82f7b843bce061ba391
  43. Order Hash: 0xe43eff38dc27af046bfbd431926926c072bbc7a509d56f6f1a7ae1f5ad7efe4f

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

Full code

Commands

  1. solc --abi Exchange.sol
  2. abigen --abi="Exchange.sol:Exchange.abi" --pkg=exchange --out=Exchange.go

Exchange.sol

  1. pragma solidity 0.4.11;
  3. contract Exchange {
  4.     event LogFill(
  5.         address indexed maker,
  6.         address taker,
  7.         address indexed feeRecipient,
  8.         address makerToken,
  9.         address takerToken,
  10.         uint filledMakerTokenAmount,
  11.         uint filledTakerTokenAmount,
  12.         uint paidMakerFee,
  13.         uint paidTakerFee,
  14.         bytes32 indexed tokens, // keccak256(makerToken, takerToken), allows subscribing to a token pair
  15.         bytes32 orderHash
  16.     );
  18.     event LogCancel(
  19.         address indexed maker,
  20.         address indexed feeRecipient,
  21.         address makerToken,
  22.         address takerToken,
  23.         uint cancelledMakerTokenAmount,
  24.         uint cancelledTakerTokenAmount,
  25.         bytes32 indexed tokens,
  26.         bytes32 orderHash
  27.     );
  29.     event LogError(uint8 indexed errorId, bytes32 indexed orderHash);
  30. }

event_read_0xprotocol.go

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "log"
  7.     "math/big"
  8.     "strconv"
  9.     "strings"
  11.     exchange "./contracts_0xprotocol" // for demo
  12.     "github.com/ethereum/go-ethereum"
  13.     "github.com/ethereum/go-ethereum/accounts/abi"
  14.     "github.com/ethereum/go-ethereum/common"
  15.     "github.com/ethereum/go-ethereum/common/hexutil"
  16.     "github.com/ethereum/go-ethereum/ethclient"
  17. )
  19. // LogFill ...
  20. type LogFill struct {
  21.     Maker                  common.Address
  22.     Taker                  common.Address
  23.     FeeRecipient           common.Address
  24.     MakerToken             common.Address
  25.     TakerToken             common.Address
  26.     FilledMakerTokenAmount *big.Int
  27.     FilledTakerTokenAmount *big.Int
  28.     PaidMakerFee           *big.Int
  29.     PaidTakerFee           *big.Int
  30.     Tokens                 [32]byte
  31.     OrderHash              [32]byte
  32. }
  34. // LogCancel ...
  35. type LogCancel struct {
  36.     Maker                     common.Address
  37.     FeeRecipient              common.Address
  38.     MakerToken                common.Address
  39.     TakerToken                common.Address
  40.     CancelledMakerTokenAmount *big.Int
  41.     CancelledTakerTokenAmount *big.Int
  42.     Tokens                    [32]byte
  43.     OrderHash                 [32]byte
  44. }
  46. // LogError ...
  47. type LogError struct {
  48.     ErrorID   uint8
  49.     OrderHash [32]byte
  50. }
  52. func main() {
  53.     client, err := ethclient.Dial("https://mainnet.infura.io")
  54.     if err != nil {
  55.         log.Fatal(err)
  56.     }
  58.     // 0x Protocol Exchange smart contract address
  59.     contractAddress := common.HexToAddress("0x12459C951127e0c374FF9105DdA097662A027093")
  60.     query := ethereum.FilterQuery{
  61.         FromBlock: big.NewInt(6383482),
  62.         ToBlock:   big.NewInt(6383488),
  63.         Addresses: []common.Address{
  64.             contractAddress,
  65.         },
  66.     }
  68.     logs, err := client.FilterLogs(context.Background(), query)
  69.     if err != nil {
  70.         log.Fatal(err)
  71.     }
  73.     contractAbi, err := abi.JSON(strings.NewReader(string(exchange.ExchangeABI)))
  74.     if err != nil {
  75.         log.Fatal(err)
  76.     }
  78.     // NOTE: keccak256("LogFill(address,address,address,address,address,uint256,uint256,uint256,uint256,bytes32,bytes32)")
  79.     logFillEvent := common.HexToHash("0d0b9391970d9a25552f37d436d2aae2925e2bfe1b2a923754bada030c498cb3")
  81.     // NOTE: keccak256("LogCancel(address,address,address,address,uint256,uint256,bytes32,bytes32)")
  82.     logCancelEvent := common.HexToHash("67d66f160bc93d925d05dae1794c90d2d6d6688b29b84ff069398a9b04587131")
  84.     // NOTE: keccak256("LogError(uint8,bytes32)")
  85.     logErrorEvent := common.HexToHash("36d86c59e00bd73dc19ba3adfe068e4b64ac7e92be35546adeddf1b956a87e90")
  87.     for _, vLog := range logs {
  88.         fmt.Printf("Log Block Number: %d\n", vLog.BlockNumber)
  89.         fmt.Printf("Log Index: %d\n", vLog.Index)
  91.         switch vLog.Topics[0].Hex() {
  92.         case logFillEvent.Hex():
  93.             fmt.Printf("Log Name: LogFill\n")
  95.             var fillEvent LogFill
  97.             err := contractAbi.Unpack(&fillEvent, "LogFill", vLog.Data)
  98.             if err != nil {
  99.                 log.Fatal(err)
  100.             }
  102.             fillEvent.Maker = common.HexToAddress(vLog.Topics[1].Hex())
  103.             fillEvent.FeeRecipient = common.HexToAddress(vLog.Topics[2].Hex())
  104.             fillEvent.Tokens = vLog.Topics[3]
  106.             fmt.Printf("Maker: %s\n", fillEvent.Maker.Hex())
  107.             fmt.Printf("Taker: %s\n", fillEvent.Taker.Hex())
  108.             fmt.Printf("Fee Recipient: %s\n", fillEvent.FeeRecipient.Hex())
  109.             fmt.Printf("Maker Token: %s\n", fillEvent.MakerToken.Hex())
  110.             fmt.Printf("Taker Token: %s\n", fillEvent.TakerToken.Hex())
  111.             fmt.Printf("Filled Maker Token Amount: %s\n", fillEvent.FilledMakerTokenAmount.String())
  112.             fmt.Printf("Filled Taker Token Amount: %s\n", fillEvent.FilledTakerTokenAmount.String())
  113.             fmt.Printf("Paid Maker Fee: %s\n", fillEvent.PaidMakerFee.String())
  114.             fmt.Printf("Paid Taker Fee: %s\n", fillEvent.PaidTakerFee.String())
  115.             fmt.Printf("Tokens: %s\n", hexutil.Encode(fillEvent.Tokens[:]))
  116.             fmt.Printf("Order Hash: %s\n", hexutil.Encode(fillEvent.OrderHash[:]))
  118.         case logCancelEvent.Hex():
  119.             fmt.Printf("Log Name: LogCancel\n")
  121.             var cancelEvent LogCancel
  123.             err := contractAbi.Unpack(&cancelEvent, "LogCancel", vLog.Data)
  124.             if err != nil {
  125.                 log.Fatal(err)
  126.             }
  128.             cancelEvent.Maker = common.HexToAddress(vLog.Topics[1].Hex())
  129.             cancelEvent.FeeRecipient = common.HexToAddress(vLog.Topics[2].Hex())
  130.             cancelEvent.Tokens = vLog.Topics[3]
  132.             fmt.Printf("Maker: %s\n", cancelEvent.Maker.Hex())
  133.             fmt.Printf("Fee Recipient: %s\n", cancelEvent.FeeRecipient.Hex())
  134.             fmt.Printf("Maker Token: %s\n", cancelEvent.MakerToken.Hex())
  135.             fmt.Printf("Taker Token: %s\n", cancelEvent.TakerToken.Hex())
  136.             fmt.Printf("Cancelled Maker Token Amount: %s\n", cancelEvent.CancelledMakerTokenAmount.String())
  137.             fmt.Printf("Cancelled Taker Token Amount: %s\n", cancelEvent.CancelledTakerTokenAmount.String())
  138.             fmt.Printf("Tokens: %s\n", hexutil.Encode(cancelEvent.Tokens[:]))
  139.             fmt.Printf("Order Hash: %s\n", hexutil.Encode(cancelEvent.OrderHash[:]))
  141.         case logErrorEvent.Hex():
  142.             fmt.Printf("Log Name: LogError\n")
  144.             errorID, err := strconv.ParseInt(vLog.Topics[1].Hex(), 16, 64)
  145.             if err != nil {
  146.                 log.Fatal(err)
  147.             }
  149.             errorEvent := &LogError{
  150.                 ErrorID:   uint8(errorID),
  151.                 OrderHash: vLog.Topics[2],
  152.             }
  154.             fmt.Printf("Error ID: %d\n", errorEvent.ErrorID)
  155.             fmt.Printf("Order Hash: %s\n", hexutil.Encode(errorEvent.OrderHash[:]))
  156.         }
  158.         fmt.Printf("\n\n")
  159.     }
  160. }

solc version used for these examples

  1. $ solc --version
  2. 0.4.11+commit.68ef5810.Emscripten.clang