FetchReceipt

Author: attente

receipts/fetch.go

@@ -0,0 +1,126 @@
+package receipts
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+
+	"github.com/0xsequence/ethkit/ethrpc"
+	"github.com/0xsequence/ethkit/go-ethereum"
+	"github.com/0xsequence/ethkit/go-ethereum/common"
+	"github.com/0xsequence/ethkit/go-ethereum/core/types"
+	sequence "github.com/0xsequence/go-sequence"
+)
+
+// FetchReceipt looks up the transaction that emitted Call* events for the given
+// digest and decodes the corresponding receipt information.
+func FetchReceipt(ctx context.Context, digest common.Hash, provider *ethrpc.Provider, fromBlock, toBlock *big.Int) (*types.Receipt, *Receipt, error) {
+	if provider == nil {
+		return nil, nil, fmt.Errorf("no provider")
+	}
+
+	query := ethereum.FilterQuery{
+		FromBlock: fromBlock,
+		ToBlock:   toBlock,
+		Topics: [][]common.Hash{
+			{sequence.V3CallSucceeded, sequence.V3CallFailed, sequence.V3CallAborted, sequence.V3CallSkipped},
+			{digest},
+		},
+	}
+
+	logs, err := provider.FilterLogs(ctx, query)
+	if err != nil {
+		return nil, nil, fmt.Errorf("unable to filter logs: %w", err)
+	}
+	if len(logs) == 0 {
+		// Fallback for legacy events where the digest is not indexed.
+		query.Topics = [][]common.Hash{{sequence.V3CallSucceeded, sequence.V3CallFailed, sequence.V3CallAborted, sequence.V3CallSkipped}}
+		logs, err = provider.FilterLogs(ctx, query)
+		if err != nil {
+			return nil, nil, fmt.Errorf("unable to filter logs without digest topic: %w", err)
+		}
+	}
+
+	log, callIndex, err := findDigestLog(logs, digest)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	receipt, err := provider.TransactionReceipt(ctx, log.TxHash)
+	if err != nil {
+		return nil, nil, fmt.Errorf("unable to get transaction receipt %v: %w", log.TxHash, err)
+	}
+
+	decoded, err := TransactionReceiptsForReceipt(ctx, receipt, provider)
+	if err != nil {
+		return receipt, nil, fmt.Errorf("unable to decode transaction receipt %v: %w", receipt.TxHash, err)
+	}
+
+	receipts := decoded.Find(digest)
+	if receipts == nil {
+		return receipt, nil, fmt.Errorf("decoded receipts do not include digest %v", digest)
+	}
+
+	if !callIndex.IsUint64() {
+		return receipt, nil, fmt.Errorf("call index %v overflows uint64", callIndex)
+	}
+
+	idx := callIndex.Uint64()
+	if idx >= uint64(len(receipts.Receipts)) {
+		return receipt, nil, fmt.Errorf("call index %d out of range for %d receipts", idx, len(receipts.Receipts))
+	}
+
+	return receipt, &receipts.Receipts[idx], nil
+}
+
+func findDigestLog(logs []types.Log, digest common.Hash) (*types.Log, *big.Int, error) {
+	var selected *types.Log
+	var callIndex *big.Int
+
+	for i := range logs {
+		log := &logs[i]
+
+		index, err := decodeCallIndex(log, digest)
+		if err != nil {
+			continue
+		}
+
+		if selected == nil || isNewerLog(log, selected) {
+			selected = log
+			callIndex = index
+		}
+	}
+
+	if selected == nil {
+		return nil, nil, fmt.Errorf("no Call* events found for digest %v", digest)
+	}
+
+	return selected, callIndex, nil
+}
+
+func decodeCallIndex(log *types.Log, digest common.Hash) (*big.Int, error) {
+	if hash, index, err := sequence.V3DecodeCallSucceededEvent(log); err == nil && hash == digest {
+		return index, nil
+	}
+	if hash, index, _, err := sequence.V3DecodeCallFailedEvent(log); err == nil && hash == digest {
+		return index, nil
+	}
+	if hash, index, _, err := sequence.V3DecodeCallAbortedEvent(log); err == nil && hash == digest {
+		return index, nil
+	}
+	if hash, index, err := sequence.V3DecodeCallSkippedEvent(log); err == nil && hash == digest {
+		return index, nil
+	}
+
+	return nil, fmt.Errorf("log %v does not match digest %v", log.TxHash, digest)
+}
+
+func isNewerLog(a, b *types.Log) bool {
+	if a.BlockNumber != b.BlockNumber {
+		return a.BlockNumber > b.BlockNumber
+	}
+	if a.TxIndex != b.TxIndex {
+		return a.TxIndex > b.TxIndex
+	}
+	return a.Index > b.Index
+}