synapsecns/sanguine

package client

import (
    "context"
    "encoding/json"
    "errors"
    "fmt"
    "github.com/synapsecns/sanguine/core/metrics"
    "github.com/synapsecns/sanguine/ethergo/client"
    "github.com/synapsecns/sanguine/ethergo/submitter"
    "io"
    "math/big"
    "net/http"
    "strings"
)

// RPCClient is an interface for the omnirpc service.
type RPCClient interface {
    submitter.ClientFetcher
    // GetEndpoint returns the endpoint for the given chainID and confirmations.
    GetEndpoint(chainID, confirmations int) string
    // GetDefaultEndpoint returns the endpoint with the default confirmation count for the chain id.
    GetDefaultEndpoint(chainID int) string
    // GetConfirmationsClient returns a client for the given chainID and confirmations.
    // TODO: consider making confirmations iota or uint8, can be easy to confuse these params
    GetConfirmationsClient(ctx context.Context, chainID, confirmations int) (client.EVM, error)
    // GetChainClient returns a client for the given chainID.
    GetChainClient(ctx context.Context, chainID int) (client.EVM, error)
    // GetChainIDs returns all chain ids.
    GetChainIDs(ctx context.Context) ([]int, error)
}

type rpcClient struct {
    config   *rpcOptions
    endpoint string
    handler  metrics.Handler
    opts     []client.Options
}

// NewOmnirpcClient creates a new RPCClient.
func NewOmnirpcClient(endpoint string, handler metrics.Handler, options ...OptionsArgsOption) RPCClient {
    c := rpcClient{}
    c.config = makeOptions(options)
    c.endpoint = endpoint
    c.handler = handler
    c.opts = append(c.opts, client.Capture(c.config.captureReqRes))

    return &c
}

func (c *rpcClient) GetClient(ctx context.Context, chainID *big.Int) (client.EVM, error) {
    if !chainID.IsInt64() {
        return nil, errors.New("chain id is not a uint64")
    }

    return c.GetChainClient(ctx, int(chainID.Uint64()))
}

func (c *rpcClient) GetEndpoint(chainID, confirmations int) (res string) {
    defer func() {
        res = strings.ReplaceAll(res, "://", "TEMP_PROTOCOL")
        res = strings.ReplaceAll(res, "//", "/")
        res = strings.ReplaceAll(res, "TEMP_PROTOCOL", "://")
    }()

    if confirmations == 0 {
        return fmt.Sprintf("%s/rpc/%d", c.endpoint, chainID)
    }
    return fmt.Sprintf("%s/confirmations/%d/rpc/%d", c.endpoint, confirmations, chainID)
}

func (c *rpcClient) GetDefaultEndpoint(chainID int) string {
    return c.GetEndpoint(chainID, c.config.confirmations)
}

func (c *rpcClient) GetConfirmationsClient(ctx context.Context, chainID, confirmations int) (client.EVM, error) {
    endpoint := c.GetEndpoint(chainID, confirmations)
    chainClient, err := client.DialBackend(ctx, endpoint, c.handler, c.opts...)
    if err != nil {
        return nil, fmt.Errorf("could not dial backend: %w", err)
    }
    return chainClient, nil
}

func (c *rpcClient) GetChainClient(ctx context.Context, chainID int) (client.EVM, error) {
    endpoint := c.GetDefaultEndpoint(chainID)
    chainClient, err := client.DialBackend(ctx, endpoint, c.handler, c.opts...)
    if err != nil {
        return nil, fmt.Errorf("could not dial backend: %w", err)
    }
    return chainClient, nil
}

func (c *rpcClient) GetChainIDs(ctx context.Context) (chainIDs []int, err error) {
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("%s/chain-ids", c.endpoint), nil)
    if err != nil {
        return nil, fmt.Errorf("could not create request: %w", err)
    }
    httpClient := new(http.Client)
    c.handler.ConfigureHTTPClient(httpClient)

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, fmt.Errorf("could not get chain ids: %w", err)
    }

    defer func() {
        _ = resp.Body.Close()
    }()

    readResp, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("could not get chain ids: %w", err)
    }

    err = json.Unmarshal(readResp, &chainIDs)
    if err != nil {
        return nil, fmt.Errorf("could not get chain ids: %w", err)
    }

    return chainIDs, nil
}