How to decode Log.Data in Go

Question

I'm fetching the logs using client.SubscribeFilterLogs. The event parameters are encoded in types.Log.Data. How can I decode it in go?

Answer 1

go-ethereum abi package in Oct 2017 got the update to unpack event output. Initially it was only able to unpack method output.

All functionality is delivered through the abi.ABI object. To use it you need to have Event ABI (JSON string). Then use func (abi *ABI) UnmarshalJSON to construct the ABI object. From there you can use the Unpack method using Data from your log object.

Bear in mind that indexed attributes go into log Topic rather than Data.

For more usage details you can follow this examples:

• ERC20 Event structure
• ERC20 Event test

NOTE: In the current implementation (2017-11-29) there is a bug with indexed attributes. I've submitted a PR for that and still waiting for the final approval.

Answer 2

Here's a full code example for anyone who's still confused (thanks to @Robert Zaremba's answer)

package main

import (
    "context"

    "log"
    "math/big"
    "strings"

    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/accounts/abi"
    "github.com/ethereum/go-ethereum/common"

    "github.com/myorg/myrepo/go-contracts/token"
    "github.com/ethereum/go-ethereum/core/types"
)


func main() {
    contractAddress := common.HexToAddress("0x0d8775f648430679a709e98d2b0cb6250d2887ef")

    query := ethereum.FilterQuery{
        Addresses: []common.Address{contractAddress},
    }

    var ch = make(chan types.Log)
    ctx := context.Background()

    sub, err := Client.SubscribeFilterLogs(ctx, query, ch)

    if err != nil {
        log.Fatal(err)
    }

    tokenAbi, err := abi.JSON(strings.NewReader(string(token.TokenABI)))

    if err != nil {
        log.Fatal(err)
    }

    for {
        select {
        case err := <-sub.Err():
            log.Fatal(err)
        case eventLog := <-ch:
            var transferEvent struct {
                From  common.Address
                To    common.Address
                Value *big.Int
            }

            err = tokenAbi.Unpack(&transferEvent, "Transfer", eventLog.Data)

            if err != nil {
                log.Println("Failed to unpack")
                continue
            }

            transferEvent.From = common.BytesToAddress(eventLog.Topics[1].Bytes())
            transferEvent.To = common.BytesToAddress(eventLog.Topics[2].Bytes())

            log.Println("From", transferEvent.From.Hex())
            log.Println("To", transferEvent.To.Hex())
            log.Println("Value", transferEvent.Value)
        }
    }
}

Answer 3

Here's how I did it using the ABI:

path, _ := filepath.Abs("./resources/etherdelta.abi")
file, err := ioutil.ReadFile(path)
if err != nil {
    fmt.Println("Failed to read file:", err)
}
edabi, err := abi.JSON(strings.NewReader(string(file)))
if err != nil {
    fmt.Println("Invalid abi:", err)
}
var orderStruct struct {
    TokenGet   common.Address
    AmountGet  *big.Int
    TokenGive  common.Address
    AmountGive *big.Int
    Expires    *big.Int
    Nonce      *big.Int
    User       common.Address
}
err = edabi.Unpack(&orderStruct, "Order", log.Data)
if err != nil {
    fmt.Println("Failed to unpack:", err)
}
fmt.Println("TokenGet:", orderStruct.TokenGet.Hex())
fmt.Println("AmountGet:", orderStruct.AmountGet.Hex())

Answer 4

data := common.TrimLeftZeroes(log.Data)
hex := common.Bytes2Hex(data)
hex = TrimLeftZeroes(hex)
if hex != "" {
    erc20Amount, err := hexutil.DecodeBig("0x" + hex)
}



func TrimLeftZeroes(hex string) string {
    idx := 0
    for ; idx < len(hex); idx++ {
        if hex[idx] != '0' {
            break
        }
    }
    return hex[idx:]
}