synapsecns/sanguine

// Package relapi provides RESTful API services for the RFQ relayer
package relapi

import (
    "context"
    "fmt"

    "github.com/ipfs/go-log"
    "github.com/synapsecns/sanguine/core/ginhelper"
    "github.com/synapsecns/sanguine/ethergo/submitter"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/gin-gonic/gin"
    "github.com/synapsecns/sanguine/core/metrics"
    baseServer "github.com/synapsecns/sanguine/core/server"
    "github.com/synapsecns/sanguine/ethergo/listener"
    omniClient "github.com/synapsecns/sanguine/services/omnirpc/client"
    "github.com/synapsecns/sanguine/services/rfq/contracts/fastbridge"
    "github.com/synapsecns/sanguine/services/rfq/relayer/chain"
    "github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
    "github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
)

// RelayerAPIServer is a struct that holds the configuration, database connection, gin engine, RPC client, metrics handler, and fast bridge contracts.
// It is used to initialize and run the API server.
type RelayerAPIServer struct {
    cfg       relconfig.Config
    db        reldb.Service
    engine    *gin.Engine
    handler   metrics.Handler
    chains    map[uint32]*chain.Chain
    submitter submitter.TransactionSubmitter
}

// NewRelayerAPI holds the configuration, database connection, gin engine, RPC client, metrics handler, and fast bridge contracts.
// It is used to initialize and run the API server.
//
//nolint:cyclop
func NewRelayerAPI(
    ctx context.Context,
    cfg relconfig.Config,
    handler metrics.Handler,
    omniRPCClient omniClient.RPCClient,
    store reldb.Service,
    submitter submitter.TransactionSubmitter,
) (*RelayerAPIServer, error) {
    if ctx == nil {
        return nil, fmt.Errorf("context is nil")
    }
    if handler == nil {
        return nil, fmt.Errorf("handler is nil")
    }
    if omniRPCClient == nil {
        return nil, fmt.Errorf("omniRPCClient is nil")
    }
    if store == nil {
        return nil, fmt.Errorf("store is nil")
    }

    chains := make(map[uint32]*chain.Chain)
    for chainID := range cfg.Chains {
        chainClient, err := omniRPCClient.GetChainClient(ctx, chainID)
        if err != nil {
            return nil, fmt.Errorf("could not create omnirpc client: %w", err)
        }
        rfqAddr, err := cfg.GetRFQAddress(chainID)
        if err != nil {
            return nil, fmt.Errorf("could not get rfq address: %w", err)
        }
        contract, err := fastbridge.NewFastBridgeRef(rfqAddr, chainClient)
        if err != nil {
            return nil, fmt.Errorf("could not create fast bridge contract: %w", err)
        }
        startBlock, err := contract.DeployBlock(&bind.CallOpts{Context: ctx})
        if err != nil {
            return nil, fmt.Errorf("could not get deploy block: %w", err)
        }
        chainListener, err := listener.NewChainListener(chainClient, store, rfqAddr, uint64(startBlock.Int64()), handler)
        if err != nil {
            return nil, fmt.Errorf("could not get chain listener: %w", err)
        }
        chains[uint32(chainID)], err = chain.NewChain(ctx, cfg, chainClient, chainListener, submitter)
        if err != nil {
            return nil, fmt.Errorf("could not create chain: %w", err)
        }
    }

    return &RelayerAPIServer{
        cfg:       cfg,
        db:        store,
        handler:   handler,
        chains:    chains,
        submitter: submitter,
    }, nil
}

const (
    getHealthRoute        = "/health"
    getRetryRoute         = "/retry"
    postWithdrawRoute     = "/withdraw"
    getTxHashByNonceRoute = "/tx_hash/by_nonce"
    getRequestByTxID      = "/request/by_tx_id"
    getRequestByTxHash    = "/request/by_tx_hash"
)

var logger = log.Logger("relayer-api")

// Run runs the rest api server.
func (r *RelayerAPIServer) Run(ctx context.Context) error {
    engine := ginhelper.New(logger)
    // default tracing middleware
    engine.Use(r.handler.Gin()...)
    h := NewHandler(r.handler, r.db, r.chains, r.cfg, r.submitter)

    // Assign GET routes
    engine.GET(getHealthRoute, h.GetHealth)
    engine.GET(getRetryRoute, h.GetTxRetry)
    engine.GET(getRequestByTxID, h.GetQuoteRequestByTxID)
    engine.GET(getRequestByTxHash, h.GetQuoteRequestByTxHash)
    engine.GET(metrics.MetricsPathDefault, gin.WrapH(r.handler.Handler()))

    if r.cfg.EnableAPIWithdrawals {
        engine.POST(postWithdrawRoute, h.Withdraw)
        engine.GET(getTxHashByNonceRoute, h.GetTxHashByNonce)
    }

    r.engine = engine

    connection := baseServer.Server{}
    fmt.Printf("starting api at http://localhost:%s\n", r.cfg.RelayerAPIPort)
    err := connection.ListenAndServe(ctx, fmt.Sprintf(":%s", r.cfg.RelayerAPIPort), r.engine)
    if err != nil {
        return fmt.Errorf("could not start relayer api server: %w", err)
    }

    return nil
}