synapsecns/sanguine

package backend

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

    "github.com/benbjohnson/immutable"
    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/lmittmann/w3/module/eth"
    "github.com/lmittmann/w3/w3types"
    "github.com/synapsecns/sanguine/core/metrics"
    "github.com/synapsecns/sanguine/ethergo/client"
    "github.com/synapsecns/sanguine/ethergo/util"
    "golang.org/x/exp/constraints"
)

// ScribeBackend is the set of functions that the scribe needs from a client.
type ScribeBackend interface {
    // ChainID gets the chain id from the rpc server.
    ChainID(ctx context.Context) (*big.Int, error)
    // BlockNumber gets the latest block number.
    BlockNumber(ctx context.Context) (uint64, error)
    // HeaderByNumber returns the block header with the given block number.
    HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
    // BatchWithContext batches multiple
    BatchWithContext(ctx context.Context, calls ...w3types.Caller) error
}

// DialBackend returns a scribe backend.
func DialBackend(ctx context.Context, url string, handler metrics.Handler) (ScribeBackend, error) {
    //nolint:wrapcheck
    return client.DialBackend(ctx, url, handler)
}

// GetLogsInRange gets all logs in a range with a single batch request
// in successful cases an immutable list is returned, otherwise an error is returned.
func GetLogsInRange(ctx context.Context, backend ScribeBackend, contractAddresses []common.Address, expectedChainID uint64, chunks []*util.Chunk, topics [][]common.Hash) (*immutable.List[*[]types.Log], error) {
    calls := make([]w3types.Caller, len(chunks)+2)
    results := make([][]types.Log, len(chunks))
    chainID := new(uint64)
    calls[0] = eth.ChainID().Returns(chainID)

    maxHeight := new(big.Int)
    calls[1] = eth.BlockNumber().Returns(maxHeight)

    for i := 0; i < len(chunks); i++ {
        startBlock := chunks[i].StartBlock
        endBlock := chunks[i].EndBlock

        // handle desc iterator
        if startBlock.Uint64() > endBlock.Uint64() {
            startBlock = chunks[i].EndBlock
            endBlock = chunks[i].StartBlock
        }
        filter := ethereum.FilterQuery{
            FromBlock: startBlock,
            ToBlock:   endBlock,
            Addresses: contractAddresses,
            Topics:    topics,
        }
        calls[i+2] = eth.Logs(filter).Returns(&results[i])
    }

    // for logging purposes
    startHeight := chunks[0].StartBlock.Uint64()
    endHeight := chunks[len(chunks)-1].EndBlock.Uint64()
    if err := backend.BatchWithContext(ctx, calls...); err != nil {
        return nil, fmt.Errorf("could not fetch logs in range %d to %d: %w", startHeight, endHeight, err)
    }
    if expectedChainID != *chainID {
        return nil, fmt.Errorf("could not fetch logs in range %d to %d: Incorrect RPC used for expected chainID: %d, RPC used chainID %d instead", startHeight, endHeight, expectedChainID, chainID)
    }
    if endHeight > maxHeight.Uint64() {
        return nil, fmt.Errorf("could not fetch logs in range %d to %d: Block not available past max height: %d", startHeight, endHeight, maxHeight.Uint64())
    }

    // use an immutable list for additional safety to the caller, don't allocate until batch returns successfully
    res := immutable.NewListBuilder[*[]types.Log]()
    for _, result := range results {
        logChunk := result
        if len(result) > 0 {
            res.Append(&logChunk)
        }
    }

    return res.List(), nil
}

// BlockHashesInRange gets all block hashes in a range with a single batch request
// in successful cases an immutable map is returned of [height->hash], otherwise an error is returned.
func BlockHashesInRange(ctx context.Context, backend ScribeBackend, startHeight uint64, endHeight uint64) (*immutable.Map[uint64, string], error) {
    // performance impact will be negligible here because of external constraints on blocksize
    blocks := MakeRange(startHeight, endHeight)
    bulkSize := len(blocks)
    calls := make([]w3types.Caller, bulkSize)
    results := make([]types.Header, bulkSize)

    for i, blockNumber := range blocks {
        calls[i] = eth.HeaderByNumber(new(big.Int).SetUint64(blockNumber)).Returns(&results[i])
    }

    if err := backend.BatchWithContext(ctx, calls...); err != nil {
        return nil, fmt.Errorf("could not fetch blocks in range %d to %d: %w", startHeight, endHeight, err)
    }

    // use an immutable map for additional safety to the caller, don't allocate until batch returns successfully
    res := immutable.NewMapBuilder[uint64, string](nil)
    for _, result := range results {
        res.Set(result.Number.Uint64(), result.Hash().String())
    }

    return res.Map(), nil
}

// MakeRange returns a range of integers from min to max inclusive.
func MakeRange[T constraints.Integer](min, max T) []T {
    a := make([]T, max-min+1)
    for i := range a {
        a[i] = min + T(i)
    }
    return a
}