synapsecns/sanguine

package client

import (
    "context"
    "fmt"
    "github.com/synapsecns/sanguine/ethergo/client"
    "math/big"
    "net/url"
    "time"

    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/ethclient"
    "github.com/ethereum/go-ethereum/params"
    "github.com/ethereum/go-ethereum/rpc"
    "github.com/lmittmann/w3"
    "github.com/lmittmann/w3/w3types"
    "github.com/pkg/errors"
)

// EVMClient is the chain client. It defines everything necessary to create a Chain.
//
// Deprecated: use ethergo/client
//
//go:generate go run github.com/vektra/mockery/v2 --name EVMClient --output ./mocks --case=underscore
type EVMClient 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)
    // BatchContext uses w3 as a helper method for batch calls
    // Deprecated: use BatchCallContext and stop using chain/client
    BatchContext(ctx context.Context, calls ...w3types.Caller) error
    // Web3Version gets the web3 version
    Web3Version(ctx context.Context) (version string, err error)
}

// clientImpl is a client implementation for an ethclient.
// it adds the chainconfig to the chain.
type clientImpl struct {
    *ethclient.Client
    // rpcClient is the underlying rpc client
    rpcClient *rpc.Client
    // w3Client is sued for batch calls
    w3Client *w3.Client
    // chainID contains the chain id
    chainID *big.Int
    // config is the chain config
    config *params.ChainConfig
    // wsURL is stored for reconnection attempts
    wsURL string
    // ctx stores the context of the original client
    //nolint: containedctx
    ctx context.Context
}

func (c *clientImpl) Web3Version(ctx context.Context) (version string, err error) {
    if err := c.rpcClient.CallContext(ctx, &version, client.Web3VersionMethod.String()); err != nil {
        // nolint: wrapcheck
        return "", err
    }
    return version, nil
}

func (c *clientImpl) BatchContext(ctx context.Context, calls ...w3types.Caller) error {
    //nolint:wrapcheck
    return c.w3Client.CallCtx(ctx, calls...)
}

// connectionResetTimeout is how long the client should wait before rehupping.
var connectionResetTimeout = time.Minute * 5

const (
    // secureWebsocketScheme defines the scheme used to connect to a secure websocket.
    secureWebsocketScheme = "wss"
    // insecureWebsocketScheme defines the scheme used to connect to an insecure websocket.
    insecureWebsocketScheme = "ws"
)

// StartConnectionResetTicker should be fired off as a goroutine upon a baseChain's
// initialization. This is only used for websocket connections
// At every connectionResetTimeout (as of writing, every 5 minutes), the client will
// attempt to reconnect to its RPC client as a way of "rehup"ing the connection, which
// is a workaround for an issue documented in https://github.com/ethereum/go-ethereum/issues/22266
// with websocket connections. This can be removed when that issue is fixed
// If the attempted reconnect fails, it is tried again on the next tick.
func (c *clientImpl) StartConnectionResetTicker(ctx context.Context) {
    parsedURL, err := url.Parse(c.wsURL)
    if err != nil {
        // this should never happen because we make sure the url can be parsed when validating the config. Nonetheless, we want to avoid a panic here
        logger.Warn(err)
        return
    }

    // we don't need to rehup if this isn't a websocket
    if parsedURL.Scheme != secureWebsocketScheme && parsedURL.Scheme != insecureWebsocketScheme {
        return
    }

    select {
    case <-ctx.Done():
        return
    case <-time.After(connectionResetTimeout):
        if err := c.AttemptReconnect(); err != nil {
            logger.Warn(errors.Wrapf(err, "reconnect attempt for Chain client for Chain ID %s failed", c.config.ChainID))
        }
    }
}

// AttemptReconnect attempts to create a new client. Because this replaces
// a pointer, this should be subscription safe.
func (c *clientImpl) AttemptReconnect() error {
    tmpRPCClient, err := rpc.DialContext(c.ctx, c.wsURL)
    if err != nil {
        return fmt.Errorf("could not create new client, continuing to use original: %w", err)
    }

    c.rpcClient = tmpRPCClient
    c.Client = ethclient.NewClient(c.rpcClient)
    c.w3Client = w3.NewClient(c.rpcClient)

    return nil
}

// CallContext exposes the CallContext methods in the underlying ethereum rpc client.
//
//nolint:wrapcheck
func (c *clientImpl) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) (err error) {
    //nolint:asasalint
    return c.rpcClient.CallContext(ctx, result, method, args)
}

// BatchCallContext calls BatchCallContext on the underlying ethereum rpc client.
//
//nolint:wrapcheck
func (c *clientImpl) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error {
    return c.rpcClient.BatchCallContext(ctx, b)
}

// NewClient creates a client from a url.
func NewClient(ctx context.Context, url string) (EVMClient, error) {
    rpcClient, err := rpc.DialContext(ctx, url)
    if err != nil {
        return nil, fmt.Errorf("could not connect to rpc server %s. Received error: %w", url, err)
    }

    ethClient := ethclient.NewClient(rpcClient)
    w3Client := w3.NewClient(rpcClient)

    chainID, err := ethClient.ChainID(ctx)
    if err != nil {
        return nil, fmt.Errorf("could not get chain id: %w", err)
    }

    client := &clientImpl{
        chainID:   chainID,
        rpcClient: rpcClient,
        Client:    ethClient,
        wsURL:     url,
        ctx:       ctx,
        w3Client:  w3Client,
    }

    go client.StartConnectionResetTicker(ctx)

    return client, nil
}

// NewClientFromChainID creates a new client from a chain id.
func NewClientFromChainID(ctx context.Context, url string, chainID *big.Int) (EVMClient, error) {
    rpcClient, err := rpc.DialContext(ctx, url)
    if err != nil {
        return nil, fmt.Errorf("could not connect to rpc server %s. Received error: %w", url, err)
    }

    ethClient := ethclient.NewClient(rpcClient)
    w3Client := w3.NewClient(rpcClient)

    client := &clientImpl{
        chainID:   chainID,
        rpcClient: rpcClient,
        Client:    ethClient,
        wsURL:     url,
        ctx:       ctx,
        w3Client:  w3Client,
    }

    go client.StartConnectionResetTicker(ctx)

    return client, nil
}