Merge pull request #139 from thirdweb-dev/vt-decoding-txs-and-events

wip: decode txs using contract api

Author: vernonjohnson

configs/config.go

@@ -109,8 +109,10 @@ type BasicAuthConfig struct {
 }
 
 type APIConfig struct {
-	Host      string          `mapstructure:"host"`
-	BasicAuth BasicAuthConfig `mapstructure:"basicAuth"`
+	Host                string          `mapstructure:"host"`
+	BasicAuth           BasicAuthConfig `mapstructure:"basicAuth"`
+	ThirdwebContractApi string          `mapstructure:"thirdwebContractApi"`
+	AbiDecodingEnabled  bool            `mapstructure:"abiDecodingEnabled"`
 }
 
 type Config struct {

internal/common/abi.go

@@ -2,12 +2,45 @@ package common
 
 import (
 	"fmt"
+	"net/http"
 	"regexp"
 	"strings"
 
+	config "github.com/thirdweb-dev/indexer/configs"
+
 	"github.com/ethereum/go-ethereum/accounts/abi"
 )
 
+func GetABIForContractWithCache(chainId string, contract string, abiCache map[string]*abi.ABI) *abi.ABI {
+	abi, ok := abiCache[contract]
+	if !ok {
+		abiResult, err := GetABIForContract(chainId, contract)
+		if err != nil {
+			abiCache[contract] = nil
+			return nil
+		} else {
+			abiCache[contract] = abiResult
+			abi = abiResult
+		}
+	}
+	return abi
+}
+
+func GetABIForContract(chainId string, contract string) (*abi.ABI, error) {
+	url := fmt.Sprintf("%s/abi/%s/%s", config.Cfg.API.ThirdwebContractApi, chainId, contract)
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get contract abi: %v", err)
+	}
+
+	abi, err := abi.JSON(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load contract abi: %v", err)
+	}
+	return &abi, nil
+}
+
 func ConstructEventABI(signature string) (*abi.Event, error) {
 	// Regex to extract the event name and parameters
 	regex := regexp.MustCompile(`^(\w+)\((.*)\)$`)

internal/common/log.go

@@ -4,6 +4,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"math/big"
+	"sync"
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	gethCommon "github.com/ethereum/go-ethereum/common"
@@ -39,6 +40,41 @@ type DecodedLog struct {
 	Decoded DecodedLogData `json:"decodedData"`
 }
 
+func DecodeLogs(chainId string, logs []Log) []*DecodedLog {
+	decodedLogs := make([]*DecodedLog, len(logs))
+	abiCache := make(map[string]*abi.ABI)
+
+	decodeLogFunc := func(eventLog *Log) *DecodedLog {
+		decodedLog := DecodedLog{Log: *eventLog}
+		abi := GetABIForContractWithCache(chainId, eventLog.Address, abiCache)
+		if abi == nil {
+			return &decodedLog
+		}
+
+		event, err := abi.EventByID(gethCommon.HexToHash(eventLog.Topics[0]))
+		if err != nil {
+			log.Debug().Msgf("failed to get method by id: %v", err)
+			return &decodedLog
+		}
+		if event == nil {
+			return &decodedLog
+		}
+		return eventLog.Decode(event)
+	}
+
+	var wg sync.WaitGroup
+	for idx, eventLog := range logs {
+		wg.Add(1)
+		go func(idx int, eventLog Log) {
+			defer wg.Done()
+			decodedLog := decodeLogFunc(&eventLog)
+			decodedLogs[idx] = decodedLog
+		}(idx, eventLog)
+	}
+	wg.Wait()
+	return decodedLogs
+}
+
 func (l *Log) Decode(eventABI *abi.Event) *DecodedLog {
 
 	decodedIndexed := make(map[string]interface{})

internal/common/transaction.go

@@ -4,6 +4,7 @@ import (
 	"encoding/hex"
 	"math/big"
 	"strings"
+	"sync"
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/rs/zerolog/log"
@@ -52,6 +53,49 @@ type DecodedTransaction struct {
 	Decoded DecodedTransactionData `json:"decodedData"`
 }
 
+func DecodeTransactions(chainId string, txs []Transaction) []*DecodedTransaction {
+	decodedTxs := make([]*DecodedTransaction, len(txs))
+	abiCache := make(map[string]*abi.ABI)
+	decodeTxFunc := func(transaction *Transaction) *DecodedTransaction {
+		decodedTransaction := DecodedTransaction{Transaction: *transaction}
+		abi := GetABIForContractWithCache(chainId, transaction.ToAddress, abiCache)
+		if abi == nil {
+			return &decodedTransaction
+		}
+
+		decodedData, err := hex.DecodeString(strings.TrimPrefix(transaction.Data, "0x"))
+		if err != nil {
+			return &decodedTransaction
+		}
+
+		if len(decodedData) < 4 {
+			return &decodedTransaction
+		}
+		methodID := decodedData[:4]
+		method, err := abi.MethodById(methodID)
+		if err != nil {
+			log.Debug().Msgf("failed to get method by id: %v", err)
+			return &decodedTransaction
+		}
+		if method == nil {
+			return &decodedTransaction
+		}
+		return transaction.Decode(method)
+	}
+
+	var wg sync.WaitGroup
+	for idx, transaction := range txs {
+		wg.Add(1)
+		go func(idx int, transaction Transaction) {
+			defer wg.Done()
+			decodedTx := decodeTxFunc(&transaction)
+			decodedTxs[idx] = decodedTx
+		}(idx, transaction)
+	}
+	wg.Wait()
+	return decodedTxs
+}
+
 func (t *Transaction) Decode(functionABI *abi.Method) *DecodedTransaction {
 	decodedData, err := hex.DecodeString(strings.TrimPrefix(t.Data, "0x"))
 	if err != nil {

internal/handlers/logs_handlers.go

@@ -209,7 +209,12 @@ func handleLogsRequest(c *gin.Context, contractAddress, signature string, eventA
 			}
 			queryResult.Data = decodedLogs
 		} else {
-			queryResult.Data = logsResult.Data
+			if config.Cfg.API.AbiDecodingEnabled {
+				decodedLogs := common.DecodeLogs(chainId.String(), logsResult.Data)
+				queryResult.Data = decodedLogs
+			} else {
+				queryResult.Data = logsResult.Data
+			}
 		}
 		queryResult.Meta.TotalItems = len(logsResult.Data)
 	}

internal/handlers/transactions_handlers.go

@@ -8,6 +8,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/rs/zerolog/log"
 	"github.com/thirdweb-dev/indexer/api"
+	config "github.com/thirdweb-dev/indexer/configs"
 	"github.com/thirdweb-dev/indexer/internal/common"
 	"github.com/thirdweb-dev/indexer/internal/rpc"
 	"github.com/thirdweb-dev/indexer/internal/storage"
@@ -219,7 +220,12 @@ func handleTransactionsRequest(c *gin.Context, contractAddress, signature string
 			}
 			queryResult.Data = decodedTransactions
 		} else {
-			queryResult.Data = transactionsResult.Data
+			if config.Cfg.API.AbiDecodingEnabled {
+				decodedTransactions := common.DecodeTransactions(chainId.String(), transactionsResult.Data)
+				queryResult.Data = decodedTransactions
+			} else {
+				queryResult.Data = transactionsResult.Data
+			}
 		}
 		queryResult.Meta.TotalItems = len(transactionsResult.Data)
 	}