synapsecns/sanguine

package near

import (
    "context"
    "encoding/json"
    "fmt"
    "math/big"

    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/common/hexutil"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/rpc"
)

// AuroraClient contains the methods necessary to use the aurora client adapter.
type AuroraClient interface {
    // CallContext performs a JSON-RPC call with the given arguments. If the context is
    // canceled before the call has successfully returned, CallContext returns immediately.
    //
    // The result must be a pointer so that package json can unmarshal into it. You
    // can also pass nil, in which case the result is ignored.
    CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error
    // BatchCallContext sends all given requests as a single batch and waits for the server
    // to return a response for all of them. The wait duration is bounded by the
    // context's deadline.
    //
    // In contrast to CallContext, BatchCallContext only returns errors that have occurred
    // while sending the request. Any error specific to a request is reported through the
    // Error field of the corresponding BatchElem.
    //
    // Note that batch calls may not be executed atomically on the server side.
    BatchCallContext(ctx context.Context, b []rpc.BatchElem) error
    // BlockNumber gets the latest block number
    BlockNumber(ctx context.Context) (uint64, error)
    // TransactionByHash gets a tx by hash
    TransactionByHash(ctx context.Context, txHash common.Hash) (tx *types.Transaction, isPending bool, err error)
}

// BlockByNumber overrides the get block unmarshalling to be compatible with near.
func BlockByNumber(ctx context.Context, c AuroraClient, number *big.Int) (*types.Block, error) {
    if number == nil {
        latestBlock, err := c.BlockNumber(ctx)
        if err != nil {
            //nolint:wrapcheck
            return nil, err
        }

        return getBlock(ctx, c, "eth_getBlockByNumber", toBlockNumArg(new(big.Int).SetUint64(latestBlock)))
    }
    return getBlock(ctx, c, "eth_getBlockByNumber", toBlockNumArg(number))
}

// BlockByHash overrides the get block unmarshalling to be compatible with near.
func BlockByHash(ctx context.Context, c AuroraClient, hash common.Hash) (*types.Block, error) {
    return getBlock(ctx, c, "eth_getBlockByHash", hash, true)
}

func toBlockNumArg(number *big.Int) string {
    if number == nil {
        return "latest"
    }
    pending := big.NewInt(-1)
    if number.Cmp(pending) == 0 {
        return "pending"
    }
    return hexutil.EncodeBig(number)
}

// see https://git.io/Jy1Oc
type rpcBlock struct {
    Hash         common.Hash   `json:"hash"`
    Transactions []common.Hash `json:"transactions"`
    UncleHashes  []common.Hash `json:"uncles"`
}

// getBlock is a temporary workaround for https://github.com/aurora-is-near/aurora-relayer/pull/141
// amd will be removed as soon as possible.
//
//nolint:gocognit,cyclop
func getBlock(ctx context.Context, c AuroraClient, method string, args ...interface{}) (*types.Block, error) {
    var raw json.RawMessage
    err := c.CallContext(ctx, &raw, method, args...)
    if err != nil {
        //nolint:wrapcheck
        return nil, err
    } else if len(raw) == 0 {
        //nolint:wrapcheck
        return nil, ethereum.NotFound
    }
    // Decode header and transactions.
    var head *types.Header
    var body rpcBlock
    if err := json.Unmarshal(raw, &head); err != nil {
        //nolint: wrapcheck
        return nil, err
    }
    if err := json.Unmarshal(raw, &body); err != nil {
        //nolint: wrapcheck
        return nil, err
    }

    // near doesn't have uncles: manually overwrite the uncle hash with the empty uncle hash
    head.UncleHash = types.EmptyUncleHash

    if len(body.Transactions) == 0 {
        head.TxHash = types.EmptyRootHash
    }

    // Quick-verify transaction and uncle lists. This mostly helps with debugging the server.
    if head.UncleHash == types.EmptyUncleHash && len(body.UncleHashes) > 0 {
        return nil, fmt.Errorf("server returned non-empty uncle list but block header indicates no uncles")
    }
    if head.UncleHash != types.EmptyUncleHash && len(body.UncleHashes) == 0 {
        return nil, fmt.Errorf("server returned empty uncle list but block header indicates uncles")
    }
    if head.TxHash == types.EmptyRootHash && len(body.Transactions) > 0 {
        return nil, fmt.Errorf("server returned non-empty transaction list but block header indicates no transactions")
    }
    if head.TxHash != types.EmptyRootHash && len(body.Transactions) == 0 {
        return nil, fmt.Errorf("server returned empty transaction list but block header indicates transactions")
    }

    // there are no uncles in aurora
    var uncles []*types.Header

    txes, err := getTransactions(ctx, c, body.Transactions, body.Hash)
    if err != nil {
        return nil, err
    }

    return types.NewBlockWithHeader(head).WithBody(txes, uncles), nil
}