So dekodieren Sie Log.Data in Go

Das go-ethereum abi- Paket hat im Oktober 2017 das Update zum Entpacken der Ereignisausgabe erhalten. Anfangs war es nur möglich, die Methodenausgabe zu entpacken.

Alle Funktionen werden über das abi.ABIObjekt bereitgestellt. Um es zu verwenden, benötigen Sie Event ABI (JSON-String). Verwenden Sie dann func (abi *ABI) UnmarshalJSON , um das ABIObjekt zu erstellen. Von dort aus können Sie die UnpackMethode using Dataaus Ihrem Protokollobjekt verwenden.

Denken Sie daran, dass indizierte Attribute Topiceher in log als in Data.

Für weitere Nutzungsdetails können Sie diesen Beispielen folgen:

• ERC20 Ereignisstruktur
• ERC20 Ereignistest

HINWEIS: In der aktuellen Implementierung (2017-11-29) gibt es einen Fehler mit indizierten Attributen. Ich habe dafür eine PR eingereicht und warte immer noch auf die endgültige Genehmigung.

Hier ist ein vollständiges Codebeispiel für alle, die immer noch verwirrt sind (dank der Antwort von @Robert Zaremba).

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)
        }
    }
}

So habe ich es mit dem ABI gemacht:

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())

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:]
}