synapsecns/sanguine

package proxy

import (
    "encoding/json"
    "fmt"
    "github.com/davecgh/go-spew/spew"
    "github.com/ethereum/go-ethereum/eth/filters"
    "github.com/ethereum/go-ethereum/rpc"
    "github.com/hashicorp/go-multierror"
    "github.com/hedzr/cmdr/tool"
    "github.com/synapsecns/sanguine/ethergo/client"
    ethergoRPC "github.com/synapsecns/sanguine/ethergo/parser/rpc"
    "golang.org/x/exp/slices"
    "math/big"
)

func isConfirmable(r ethergoRPC.Request) (bool, error) {
    // TODO: should we error on default?
    // TODO: look at RPCMethod.Comparable for lower, necessary?
    //nolint: exhaustive
    switch client.RPCMethod(r.Method) {
    case client.BlockByNumberMethod, client.PendingTransactionCountMethod:
        return isBlockNumConfirmable(r.Params[0]), nil
    case client.BlockNumberMethod, client.SyncProgressMethod, client.GasPriceMethod, client.MaxPriorityMethod, client.EstimateGasMethod:
        return false, nil
    case client.GetBalanceMethod, client.GetCodeMethod, client.TransactionCountMethod, client.CallMethod:
        return isBlockNumConfirmable(r.Params[1]), nil
    case client.StorageAtMethod:
        return isBlockNumConfirmable(r.Params[2]), nil
    case client.GetLogsMethod:
        return isFilterArgConfirmable(r.Params[0])
    // not confirmable because tx could be pending. We might want to handle w/ omnicast though
    // left separate for comment
    case client.SendRawTransactionMethod:
        return false, nil
    }
    return true, nil
}

func areConfirmable(r ethergoRPC.Requests) (_ bool, errs error) {
    unconfirmable := false

    for i, request := range r {
        canConfirm, err := isConfirmable(request)
        if err != nil {
            errs = multierror.Append(errs, fmt.Errorf("request at index %d: %s is not parsable", i, spew.Sprint(request)))
        }

        if !canConfirm {
            unconfirmable = true
        }
    }

    if errs != nil {
        //nolint:wrapcheck
        return false, errs
    }

    return !unconfirmable, nil
}

func isBlockNumConfirmable(arg json.RawMessage) bool {
    // nonConfirmableBlockNumArgs is a list of non numerical block args
    var nonConfirmableBlockNumArgs = []string{"latest", "pending"}

    return !slices.Contains(nonConfirmableBlockNumArgs, tool.StripQuotes(string(arg)))
}

// isFilterArgConfirmable checks if filter.filterCriteria is confirmable.
func isFilterArgConfirmable(arg json.RawMessage) (bool, error) {
    // cast latest block number to a big int for comparison
    latestBlockNumber := new(big.Int).SetInt64(rpc.LatestBlockNumber.Int64())

    filterCriteria := filters.FilterCriteria{}
    err := filterCriteria.UnmarshalJSON(arg)
    if err != nil {
        return false, fmt.Errorf("could not unmarshall filter: %w", err)
    }

    // Block filter requested, construct a single-shot filter
    if filterCriteria.BlockHash != nil {
        return true, nil
    }

    usesLatest := filterCriteria.FromBlock.Cmp(latestBlockNumber) == 0 || filterCriteria.ToBlock.Cmp(latestBlockNumber) == 0
    return !usesLatest, nil
}