synapsecns/sanguine

package london

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

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
    "github.com/ethereum/go-ethereum/core"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/eth/gasprice"
    "github.com/ethereum/go-ethereum/event"
    "github.com/ethereum/go-ethereum/params"
    "github.com/ethereum/go-ethereum/rpc"
    "github.com/synapsecns/sanguine/ethergo/chain/gas/backend"
)

// NewOracleBackendFromHeight creates a fee oracle for deterministically generating gas prices from a given height
// that hijacks the header by number method (when it's passed -1) and returns the block height passed in the constructor
// it also overrides PendingBlockAndReceipts to always return nil since these cannot deterministically be used cross-client.
func NewOracleBackendFromHeight(chain backend.OracleBackendChain, height uint64) HeightOracleBackend {
    return HeightOracleBackend{
        chain:  chain,
        height: height,
    }
}

// HeightOracleBackend is an oracle that deterministically gets gas + fee prices for a given backend.
type HeightOracleBackend struct {
    chain  backend.OracleBackendChain
    height uint64
}

// SubscribeChainHeadEvent is not used, but required for analytics compatibility).
func (h HeightOracleBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {
    return nil
}

// HeaderByNumber wraps oracle baccend.
//
//nolint:wrapcheck
func (h HeightOracleBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
    if number == rpc.LatestBlockNumber {
        return h.chain.HeaderByNumber(ctx, big.NewInt(int64(h.height)))
    }
    return h.chain.HeaderByNumber(ctx, big.NewInt(int64(number)))
}

// BlockByNumber wraps the oracle backend.
//
//nolint:wrapcheck
func (h HeightOracleBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
    return h.chain.BlockByNumber(ctx, big.NewInt(int64(number)))
}

// GetReceipts gets receipts for a block in a single rpc call.
//
//nolint:wrapcheck
func (h HeightOracleBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
    block, err := h.chain.BlockByHash(ctx, hash)
    if err != nil {
        return nil, fmt.Errorf("could not fetch block with hash: %s: %w", hash, err)
    }

    var receipts types.Receipts

    var blobGasPrice *big.Int
    if block.ExcessBlobGas() != nil {
        blobGasPrice = eip4844.CalcBlobFee(*block.ExcessBlobGas())
    }

    err = receipts.DeriveFields(h.ChainConfig(), hash, block.NumberU64(), block.Time(), block.BaseFee(), blobGasPrice, block.Transactions())
    if err != nil {
        return nil, fmt.Errorf("could not derive receipts from block: %w", err)
    }

    return receipts, nil
}

// PendingBlockAndReceipts always returns nil since we can't use this cross-client in a deterministic way.
func (h HeightOracleBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) {
    return nil, nil
}

// ChainConfig gets the chainconfig for the chain.
func (h HeightOracleBackend) ChainConfig() *params.ChainConfig {
    return h.chain.ChainConfig()
}

var _ gasprice.OracleBackend = &HeightOracleBackend{}