Add relayer API

.golangci.yml

@@ -92,6 +92,7 @@ linters:
     - nonamedreturns
     - contextcheck
     - nosnakecase
+    - depguard
   fast: false
 
 issues:

services/rfq/relayer/listener/listener_test.go

@@ -2,13 +2,14 @@ package listener_test
 
 import (
 	"context"
+	"math/big"
+	"sync"
+
 	"github.com/brianvoe/gofakeit/v6"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/listener"
-	"math/big"
-	"sync"
 )
 
 func (l *ListenerTestSuite) TestListenForEvents() {
@@ -27,11 +28,13 @@ func (l *ListenerTestSuite) TestListenForEvents() {
 			txID := [32]byte(crypto.Keccak256(testAddress.Bytes()))
 			bridgeRequestTX, err := handle.MockBridgeRequestRaw(auth.TransactOpts, txID, testAddress, []byte(gofakeit.Sentence(10)))
 			l.NoError(err)
+			l.NotNil(bridgeRequestTX)
 
 			l.backend.WaitForConfirmation(l.GetTestContext(), bridgeRequestTX)
 
 			bridgeResponseTX, err := handle.MockBridgeRelayer(auth.TransactOpts, txID, testAddress, testAddress, testAddress, new(big.Int).SetUint64(gofakeit.Uint64()), new(big.Int).SetUint64(gofakeit.Uint64()))
 			l.NoError(err)
+			l.NotNil(bridgeResponseTX)
 			l.backend.WaitForConfirmation(l.GetTestContext(), bridgeResponseTX)
 		}(i)
 	}

services/rfq/relayer/relapi/handler.go

@@ -0,0 +1,126 @@
+package relapi
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/gin-gonic/gin"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/service"
+)
+
+// Handler is the REST API handler.
+type Handler struct {
+	db     reldb.Service
+	chains map[uint32]*service.Chain
+}
+
+// NewHandler creates a new REST API handler.
+func NewHandler(db reldb.Service, chains map[uint32]*service.Chain) *Handler {
+	return &Handler{
+		db:     db, // Store the database connection in the handler
+		chains: chains,
+	}
+}
+
+// GetHealth returns a successful response to signify the API is up and running.
+func (h *Handler) GetHealth(c *gin.Context) {
+	c.JSON(http.StatusOK, gin.H{"status": "ok"})
+}
+
+const unspecifiedTxHash = "Must specify 'hash' (corresponding to origin tx)"
+
+// GetQuoteRequestStatusByTxHash gets the status of a quote request, given an origin tx hash.
+func (h *Handler) GetQuoteRequestStatusByTxHash(c *gin.Context) {
+	txHashStr := c.Query("hash")
+	if txHashStr == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": unspecifiedTxHash})
+		return
+	}
+
+	txHash := common.HexToHash(txHashStr)
+	quoteRequest, err := h.db.GetQuoteRequestByOriginTxHash(c, txHash)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	resp := GetQuoteRequestStatusResponse{
+		Status:       quoteRequest.Status.String(),
+		TxID:         hexutil.Encode(quoteRequest.TransactionID[:]),
+		OriginTxHash: quoteRequest.OriginTxHash.String(),
+		DestTxHash:   quoteRequest.DestTxHash.String(),
+	}
+	c.JSON(http.StatusOK, resp)
+}
+
+// GetQuoteRequestStatusByTxID gets the status of a quote request, given a tx id.
+func (h *Handler) GetQuoteRequestStatusByTxID(c *gin.Context) {
+	txIDStr := c.Query("id")
+	if txIDStr == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Must specify 'txID'"})
+		return
+	}
+
+	txIDBytes, err := hexutil.Decode(txIDStr)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid txID"})
+		return
+	}
+	var txID [32]byte
+	copy(txID[:], txIDBytes)
+
+	quoteRequest, err := h.db.GetQuoteRequestByID(c, txID)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	resp := GetQuoteRequestStatusResponse{
+		Status:       quoteRequest.Status.String(),
+		TxID:         hexutil.Encode(quoteRequest.TransactionID[:]),
+		OriginTxHash: quoteRequest.OriginTxHash.String(),
+		DestTxHash:   quoteRequest.DestTxHash.String(),
+	}
+	c.JSON(http.StatusOK, resp)
+}
+
+// GetTxRetry retries a transaction based on tx hash.
+func (h *Handler) GetTxRetry(c *gin.Context) {
+	txHashStr := c.Query("hash")
+	if txHashStr == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": unspecifiedTxHash})
+		return
+	}
+
+	txHash := common.HexToHash(txHashStr)
+	quoteRequest, err := h.db.GetQuoteRequestByOriginTxHash(c, txHash)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	chainID := quoteRequest.Transaction.DestChainId
+	chain, ok := h.chains[chainID]
+	if !ok {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("No contract found for chain: %d", chainID)})
+		return
+	}
+
+	// `quoteRequest == nil` case should be handled by the db query above
+	nonce, gasAmount, err := service.SubmitRelay(c, chain, *quoteRequest)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("could not submit relay: %s", err.Error())})
+		return
+	}
+
+	resp := GetTxRetryResponse{
+		TxID:      hexutil.Encode(quoteRequest.TransactionID[:]),
+		ChainID:   chainID,
+		Nonce:     nonce,
+		GasAmount: gasAmount.String(),
+	}
+	c.JSON(http.StatusOK, resp)
+}

services/rfq/relayer/relapi/model.go

@@ -0,0 +1,17 @@
+package relapi
+
+// GetQuoteRequestStatusResponse contains the schema for a GET /quote response.
+type GetQuoteRequestStatusResponse struct {
+	Status       string `json:"status"`
+	TxID         string `json:"tx_id"`
+	OriginTxHash string `json:"origin_tx_hash"`
+	DestTxHash   string `json:"dest_tx_hash"`
+}
+
+// GetTxRetryResponse contains the schema for a PUT /tx/retry response.
+type GetTxRetryResponse struct {
+	TxID      string `json:"tx_id"`
+	ChainID   uint32 `json:"chain_id"`
+	Nonce     uint64 `json:"nonce"`
+	GasAmount string `json:"gas_amount"`
+}

services/rfq/relayer/relapi/server.go

@@ -0,0 +1,111 @@
+// 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/common"
+	"github.com/gin-gonic/gin"
+	"github.com/synapsecns/sanguine/core/metrics"
+	baseServer "github.com/synapsecns/sanguine/core/server"
+	omniClient "github.com/synapsecns/sanguine/services/omnirpc/client"
+	"github.com/synapsecns/sanguine/services/rfq/api/config"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/listener"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/service"
+)
+
+// 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     config.Config
+	db      reldb.Service
+	engine  *gin.Engine
+	handler metrics.Handler
+	chains  map[uint32]*service.Chain
+}
+
+// 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.
+func NewRelayerAPI(
+	ctx context.Context,
+	cfg config.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]*service.Chain)
+	for chainID, bridge := range cfg.Bridges {
+		chainClient, err := omniRPCClient.GetChainClient(ctx, int(chainID))
+		if err != nil {
+			return nil, fmt.Errorf("could not create omnirpc client: %w", err)
+		}
+		chainListener, err := listener.NewChainListener(chainClient, store, common.HexToAddress(bridge), handler)
+		if err != nil {
+			return nil, fmt.Errorf("could not get chain listener: %w", err)
+		}
+		chains[chainID], err = service.NewChain(ctx, chainClient, common.HexToAddress(bridge), 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,
+	}, nil
+}
+
+const (
+	getHealthRoute              = "/health"
+	getQuoteStatusByTxHashRoute = "/status"
+	getQuoteStatusByTxIDRoute   = "/status/by_tx_id"
+	getRetryRoute               = "/retry"
+)
+
+var logger = log.Logger("relayer-api")
+
+// Run runs the rest api server.
+func (r *RelayerAPIServer) Run(ctx context.Context) error {
+	// TODO: Use Gin Helper
+	engine := ginhelper.New(logger)
+	h := NewHandler(r.db, r.chains)
+
+	// Assign GET routes
+	engine.GET(getHealthRoute, h.GetHealth)
+	engine.GET(getQuoteStatusByTxHashRoute, h.GetQuoteRequestStatusByTxHash)
+	engine.GET(getQuoteStatusByTxIDRoute, h.GetQuoteRequestStatusByTxID)
+	engine.GET(getRetryRoute, h.GetTxRetry)
+
+	r.engine = engine
+
+	connection := baseServer.Server{}
+	fmt.Printf("starting api at http://localhost:%s\n", r.cfg.Port)
+	err := connection.ListenAndServe(ctx, fmt.Sprintf(":%s", r.cfg.Port), r.engine)
+	if err != nil {
+		return fmt.Errorf("could not start relayer api server: %w", err)
+	}
+
+	return nil
+}