synapsecns/sanguine

package client

import (
    "context"
    "fmt"
    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/ethclient"
    "github.com/ethereum/go-ethereum/rpc"
    "github.com/lmittmann/w3"
    "github.com/lmittmann/w3/w3types"
    "github.com/synapsecns/sanguine/core/metrics"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/trace"
    "math/big"
    "reflect"
)

// EVM is the set of functions that the scribe needs from a client.
//
//go:generate go run github.com/vektra/mockery/v2 --name=EVM --output=mocks --case=underscore
type EVM interface {
    // ContractBackend defines the methods needed to work with contracts on a read-write basis.
    // this is used for deploying an interacting with contracts
    bind.ContractBackend
    // ChainReader ethereum.ChainReader for getting transactions
    ethereum.ChainReader
    // TransactionReader is used for reading txes by hash
    ethereum.TransactionReader
    // ChainStateReader gets the chain state reader
    ethereum.ChainStateReader
    // PendingStateReader handles pending state calls
    ethereum.PendingStateReader
    // ChainSyncReader tracks state head
    ethereum.ChainSyncReader
    // PendingContractCaller tracks pending contract calls
    ethereum.PendingContractCaller
    // FeeHistory gets the fee history for a given block
    FeeHistory(ctx context.Context, blockCount uint64, lastBlock *big.Int, rewardPercentiles []float64) (*ethereum.FeeHistory, error)
    // NetworkID returns the network ID (also known as the chain ID) for this chain.
    NetworkID(ctx context.Context) (*big.Int, error)
    // ChainID gets the chain id from the rpc server
    ChainID(ctx context.Context) (*big.Int, error)
    // CallContext is used for manual overrides
    CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error
    // BatchCallContext is used for manual overrides
    BatchCallContext(ctx context.Context, b []rpc.BatchElem) error
    // BlockNumber gets the latest block number
    BlockNumber(ctx context.Context) (uint64, error)
    // BatchWithContext batches multiple w3type calls
    BatchWithContext(ctx context.Context, calls ...w3types.Caller) error
    // Web3Version gets the web3 version
    Web3Version(ctx context.Context) (version string, err error)
}

type clientImpl struct {
    tracing           metrics.Handler
    captureClient     *captureClient
    endpoint          string
    captureRequestRes bool
    rpcClient         *rpc.Client
    // TODO: consider using sync.Pool for capture clients to improve performance
}

// DialBackend returns a scribe backend.
func DialBackend(ctx context.Context, url string, handler metrics.Handler, opts ...Options) (_ EVM, err error) {
    client := &clientImpl{
        endpoint: url,
        tracing:  handler,
    }

    for _, opt := range opts {
        opt(client)
    }

    // TODO: port to master wether or not pr gets merged
    client.captureClient, err = newCaptureClient(ctx, url, handler, client.captureRequestRes)
    if err != nil {
        return nil, fmt.Errorf("could not create capture client: %w", err)
    }

    client.rpcClient = client.captureClient.rpcClient

    return client, nil
}

const (
    batchAttribute    = "batch"
    methodsAttribute  = "methods"
    endpointAttribute = "endpoint"
)

func (c *clientImpl) getEthClient() *ethclient.Client {
    return c.captureClient.ethClient
}

func (c *clientImpl) getW3Client() *w3.Client {
    return c.captureClient.w3Client
}

// BatchWithContext batches multiple w3 calls.
func (c *clientImpl) BatchWithContext(ctx context.Context, calls ...w3types.Caller) (err error) {
    ctx, span := c.tracing.Tracer().Start(ctx, batchAttribute)
    span.SetAttributes(parseCalls(calls))
    span.SetAttributes(attribute.String(endpointAttribute, c.endpoint))

    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()
    //nolint: wrapcheck
    return c.getW3Client().CallCtx(ctx, calls...)
}

// BatchCallContext calls BatchCallContext on the underlying client. Note: this will bypass the rate-limiter.
//
//nolint:wrapcheck
func (c *clientImpl) BatchCallContext(ctx context.Context, b []rpc.BatchElem) (err error) {
    requestCtx, span := c.startSpan(ctx, NetVersionMethod)
    span.SetAttributes(parseBatch(b))
    span.SetAttributes(attribute.String(endpointAttribute, c.endpoint))

    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.captureClient.rpcClient.BatchCallContext(requestCtx, b)
}

func (c *clientImpl) startSpan(parentCtx context.Context, method RPCMethod, opts ...trace.SpanStartOption) (context.Context, trace.Span) {
    ctx, span := c.tracing.Tracer().Start(parentCtx, method.String(), opts...)
    span.SetAttributes(attribute.String("endpoint", c.endpoint))

    return ctx, span
}

// CallContract calls contract on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) (contractResponse []byte, err error) {
    requestCtx, span := c.startSpan(ctx, CallMethod, trace.WithAttributes(attribute.String(metrics.ContractAddress, nillableToString(call.To)), attribute.String("data", common.Bytes2Hex(call.Data)), attribute.Bool("pending", false)))
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().CallContract(requestCtx, call, blockNumber)
}

// toStrings converts a slice of any type that satisfies the Stringer interface into a slice of strings.
func toStrings[T fmt.Stringer](items []T) (res []string) {
    for _, item := range items {
        res = append(res, item.String())
    }
    return res
}

func nillableToString(nillable fmt.Stringer) string {
    if nillable == nil {
        return ""
    }

    // Use reflection to check if the interface's underlying value is nil.
    val := reflect.ValueOf(nillable)
    if val.Kind() == reflect.Ptr && val.IsNil() {
        return ""
    }

    return nillable.String()
}

// PendingCallContract calls contract on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) PendingCallContract(ctx context.Context, call ethereum.CallMsg) (contractResponse []byte, err error) {
    requestCtx, span := c.startSpan(ctx, CallMethod, trace.WithAttributes(attribute.String(metrics.ContractAddress, nillableToString(call.To)), attribute.String("data", common.Bytes2Hex(call.Data)), attribute.Bool("pending", true)))
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().PendingCallContract(requestCtx, call)
}

// PendingCodeAt calls PendingCodeAt on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) PendingCodeAt(ctx context.Context, account common.Address) (codeResponse []byte, err error) {
    requestCtx, span := c.startSpan(ctx, GetCodeMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().PendingCodeAt(requestCtx, account)
}

// PendingBalanceAt calls PendingBalanceAt on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) PendingBalanceAt(ctx context.Context, account common.Address) (pendingBalance *big.Int, err error) {
    requestCtx, span := c.startSpan(ctx, GetBalanceMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().PendingBalanceAt(requestCtx, account)
}

// PendingStorageAt calls PendingStorageAt on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) PendingStorageAt(ctx context.Context, account common.Address, key common.Hash) (pendingStorage []byte, err error) {
    requestCtx, span := c.startSpan(ctx, StorageAtMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().PendingStorageAt(requestCtx, account, key)
}

// PendingNonceAt calls PendingNonceAt on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) PendingNonceAt(ctx context.Context, account common.Address) (pendingNonce uint64, err error) {
    requestCtx, span := c.startSpan(ctx, TransactionCountMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().PendingNonceAt(requestCtx, account)
}

// PendingTransactionCount calls PendingTransactionCount on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) PendingTransactionCount(ctx context.Context) (count uint, err error) {
    requestCtx, span := c.startSpan(ctx, PendingTransactionCountMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().PendingTransactionCount(requestCtx)
}

// NetworkID calls NetworkID on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) NetworkID(ctx context.Context) (id *big.Int, err error) {
    requestCtx, span := c.startSpan(ctx, NetVersionMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().NetworkID(requestCtx)
}

// Web3Version calls Web3Version on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) Web3Version(ctx context.Context) (version string, err error) {
    requestCtx, span := c.startSpan(ctx, Web3VersionMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    var ver string
    if err := c.rpcClient.CallContext(requestCtx, &ver, Web3VersionMethod.String()); err != nil {
        return "", err
    }
    return ver, nil
}

// SyncProgress calls SyncProgress on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) SyncProgress(ctx context.Context) (syncProgress *ethereum.SyncProgress, err error) {
    requestCtx, span := c.startSpan(ctx, SyncProgressMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()
    return c.getEthClient().SyncProgress(requestCtx)
}

// SuggestGasPrice calls SuggestGasPrice on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) SuggestGasPrice(ctx context.Context) (gasPrice *big.Int, err error) {
    requestCtx, span := c.startSpan(ctx, GasPriceMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().SuggestGasPrice(requestCtx)
}

// EstimateGas calls EstimateGas on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error) {
    requestCtx, span := c.startSpan(ctx, EstimateGasMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().EstimateGas(requestCtx, call)
}

// SendTransaction calls SendTransaction on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) SendTransaction(ctx context.Context, tx *types.Transaction) (err error) {
    requestCtx, span := c.startSpan(ctx, SendRawTransactionMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().SendTransaction(requestCtx, tx)
}

func queryToTraceParams(query ethereum.FilterQuery) (res []attribute.KeyValue) {
    res = append(res, attribute.String(metrics.BlockHash, nillableToString(query.BlockHash)))
    res = append(res, attribute.String(metrics.FromBlock, nillableToString(query.FromBlock)))
    res = append(res, attribute.String(metrics.ToBlock, nillableToString(query.ToBlock)))
    res = append(res, attribute.StringSlice("addresses", toStrings(query.Addresses)))
    // TODO: add topics

    return res
}

// FilterLogs calls FilterLogs on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) FilterLogs(ctx context.Context, query ethereum.FilterQuery) (logs []types.Log, err error) {
    requestCtx, span := c.startSpan(ctx, GetLogsMethod, trace.WithAttributes(queryToTraceParams(query)...))
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().FilterLogs(requestCtx, query)
}

// SubscribeFilterLogs calls SubscribeFilterLogs on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (sub ethereum.Subscription, err error) {
    requestCtx, span := c.startSpan(ctx, SubscribeMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()
    return c.getEthClient().SubscribeFilterLogs(requestCtx, query, ch)
}

// BlockByHash calls BlockByHash on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) BlockByHash(ctx context.Context, hash common.Hash) (block *types.Block, err error) {
    requestCtx, span := c.startSpan(ctx, BlockByHashMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().BlockByHash(requestCtx, hash)
}

// BlockByNumber calls BlockByNumber on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) BlockByNumber(ctx context.Context, number *big.Int) (block *types.Block, err error) {
    requestCtx, span := c.startSpan(ctx, BlockByNumberMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().BlockByNumber(requestCtx, number)
}

// HeaderByHash calls HeaderByHash on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) HeaderByHash(ctx context.Context, hash common.Hash) (header *types.Header, err error) {
    requestCtx, span := c.startSpan(ctx, BlockByHashMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().HeaderByHash(requestCtx, hash)
}

// HeaderByNumber calls HeaderByNumber on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) HeaderByNumber(ctx context.Context, number *big.Int) (header *types.Header, err error) {
    requestCtx, span := c.startSpan(ctx, BlockByNumberMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().HeaderByNumber(requestCtx, number)
}

// TransactionCount calls TransactionCount on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) TransactionCount(ctx context.Context, blockHash common.Hash) (txCount uint, err error) {
    requestCtx, span := c.startSpan(ctx, TransactionCountByHashMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().TransactionCount(requestCtx, blockHash)
}

// TransactionInBlock calls TransactionInBlock on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) TransactionInBlock(ctx context.Context, blockHash common.Hash, index uint) (tx *types.Transaction, err error) {
    requestCtx, span := c.startSpan(ctx, TransactionByBlockHashAndIndexMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().TransactionInBlock(requestCtx, blockHash, index)
}

// SubscribeNewHead calls SubscribeNewHead on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (sub ethereum.Subscription, err error) {
    requestCtx, span := c.startSpan(ctx, SubscribeMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().SubscribeNewHead(requestCtx, ch)
}

// TransactionByHash calls TransactionByHash on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) TransactionByHash(ctx context.Context, txHash common.Hash) (tx *types.Transaction, isPending bool, err error) {
    requestCtx, span := c.startSpan(ctx, TransactionByHashMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().TransactionByHash(requestCtx, txHash)
}

// TransactionReceipt calls TransactionReceipt on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) TransactionReceipt(ctx context.Context, txHash common.Hash) (receipt *types.Receipt, err error) {
    requestCtx, span := c.startSpan(ctx, TransactionReceiptByHashMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().TransactionReceipt(requestCtx, txHash)
}

// BalanceAt calls BalanceAt on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (balance *big.Int, err error) {
    requestCtx, span := c.startSpan(ctx, GetBalanceMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().BalanceAt(requestCtx, account, blockNumber)
}

// StorageAt calls StorageAt on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) StorageAt(ctx context.Context, account common.Address, key common.Hash, blockNumber *big.Int) (storage []byte, err error) {
    requestCtx, span := c.startSpan(ctx, StorageAtMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().StorageAt(requestCtx, account, key, blockNumber)
}

// BlockNumber gets the latest block number
//
//nolint:wrapcheck
func (c *clientImpl) BlockNumber(ctx context.Context) (_ uint64, err error) {
    requestCtx, span := c.startSpan(ctx, BlockNumberMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().BlockNumber(requestCtx)
}

// CodeAt calls CodeAt on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) (codeAt []byte, err error) {
    requestCtx, span := c.startSpan(ctx, GetCodeMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().CodeAt(requestCtx, account, blockNumber)
}

// SuggestGasTipCap gets the suggested gas tip for a chain.
//
//nolint:wrapcheck
func (c *clientImpl) SuggestGasTipCap(ctx context.Context) (tip *big.Int, err error) {
    requestCtx, span := c.startSpan(ctx, MaxPriorityMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().SuggestGasTipCap(requestCtx)
}

// CallContext calls CallContext on the underlying client. Note: this will bypass the rate-limiter.
//
//nolint:wrapcheck
func (c *clientImpl) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) (err error) {
    requestCtx, span := c.startSpan(ctx, RPCMethod(method))
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.captureClient.rpcClient.CallContext(requestCtx, result, method, args...)
}

// NonceAt calls NonceAt on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (nonce uint64, err error) {
    requestCtx, span := c.startSpan(ctx, TransactionCountMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()
    return c.getEthClient().NonceAt(requestCtx, account, blockNumber)
}

// ChainID calls ChainID on the underlying client.
//
//nolint:wrapcheck
func (c *clientImpl) ChainID(ctx context.Context) (chainID *big.Int, err error) {
    requestCtx, span := c.startSpan(ctx, ChainIDMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().ChainID(requestCtx)
}

// FeeHistory calls FeeHistory on the underlying client
//
//nolint:wrapcheck
func (c *clientImpl) FeeHistory(ctx context.Context, blockCount uint64, lastBlock *big.Int, rewardPercentiles []float64) (_ *ethereum.FeeHistory, err error) {
    requestCtx, span := c.startSpan(ctx, FeeHistoryMethod)
    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    return c.getEthClient().FeeHistory(requestCtx, blockCount, lastBlock, rewardPercentiles)
}

// parseCalls parses out calls from w3types.Caller.
func parseCalls(calls []w3types.Caller) attribute.KeyValue {
    res := make([]string, len(calls))

    for i, call := range calls {
        req, err := call.CreateRequest()
        if err != nil {
            res[i] = fmt.Sprintf("unknown: %v", err)
            continue
        }
        res[i] = req.Method
    }

    return attribute.StringSlice(methodsAttribute, res)
}

func parseBatch(batchElem []rpc.BatchElem) attribute.KeyValue {
    res := make([]string, len(batchElem))

    for i, elem := range batchElem {
        res[i] = elem.Method
    }

    return attribute.StringSlice(methodsAttribute, res)
}