synapsecns/sanguine

package util

import (
    "fmt"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "go.opentelemetry.io/otel/attribute"
    "math/big"
)

const nullFieldAttribute = "null"

const (
    hashAttr      = "tx.Hash"
    fromAttr      = "tx.From"
    toAttr        = "tx.To"
    dataAttr      = "tx.Data"
    valueAttr     = "tx.Value"
    nonceAttr     = "tx.Nonce"
    gasLimitAttr  = "tx.GasLimit"
    chainIDAttr   = "tx.ChainID"
    gasPriceAttr  = "tx.GasPrice"
    gasFeeCapAttr = "tx.GasFeeCap"
    gasTipCapAttr = "tx.GasTipCap"
    txRawAttr     = "tx.Raw"
)

// TxToAttributes converts a transaction to a slice of attribute.KeyValue.
func TxToAttributes(transaction *types.Transaction) []attribute.KeyValue {
    var from string
    call, err := TxToCall(transaction)
    if err != nil {
        from = fmt.Sprintf("could not be detected: %v", err)
    } else {
        from = call.From.Hex()
    }

    bin, err := transaction.MarshalBinary()
    if err != nil {
        bin = []byte(fmt.Sprintf("could not be marshaled: %v", err))
    }

    var attributes = []attribute.KeyValue{
        attribute.String(hashAttr, transaction.Hash().Hex()),
        attribute.String(fromAttr, from),
        attribute.String(toAttr, addressPtrToString(transaction.To())),
        attribute.String(dataAttr, fmt.Sprintf("%x", transaction.Data())),
        attribute.String(valueAttr, BigPtrToString(transaction.Value())),
        // TODO: this could be downcast to int64, but it's unclear how we should handle overflows.
        // since this is only for tracing, we can probably ignore it for now.
        // nolint: gosec
        attribute.Int64(nonceAttr, int64(transaction.Nonce())),
        // nolint: gosec
        attribute.Int64(gasLimitAttr, int64(transaction.Gas())),
        attribute.String(chainIDAttr, BigPtrToString(transaction.ChainId())),
        attribute.String(txRawAttr, common.Bytes2Hex(bin)),
    }

    if transaction.Type() == types.LegacyTxType && transaction.GasPrice() != nil {
        attributes = append(attributes, attribute.String(gasPriceAttr, BigPtrToString(transaction.GasPrice())))
    }

    if transaction.Type() == types.DynamicFeeTxType && transaction.GasFeeCap() != nil {
        attributes = append(attributes, attribute.String(gasFeeCapAttr, BigPtrToString(transaction.GasFeeCap())))
    }

    if transaction.Type() == types.DynamicFeeTxType && transaction.GasTipCap() != nil {
        attributes = append(attributes, attribute.String(gasTipCapAttr, BigPtrToString(transaction.GasTipCap())))
    }

    return attributes
}

func addressPtrToString(address *common.Address) string {
    if address == nil {
        return nullFieldAttribute
    }
    return address.Hex()
}

// BigPtrToString converts a big.Int pointer to a string.
// TODO: move to core.
func BigPtrToString(num *big.Int) string {
    if num == nil {
        return nullFieldAttribute
    }
    return num.String()
}