rfq: mimimal viable withdrawal api

contrib/opbot/config/config.go

@@ -15,6 +15,7 @@ type Config struct {
 	// inject only with init container!
 	SignozPassword string `yaml:"signoz_password"`
 	// SignozBaseURL is the base url of the signoz instance.
-	SignozBaseURL string   `yaml:"signoz_base_url"`
-	RelayerURLS   []string `yaml:"rfq_relayer_urls"`
+	SignozBaseURL string `yaml:"signoz_base_url"`
+	// RelayerURLS is the list of RFQ relayer URLs.
+	RelayerURLS []string `yaml:"rfq_relayer_urls"`
 }

ethergo/submitter/submitter.go

@@ -46,6 +46,8 @@ type TransactionSubmitter interface {
 	SubmitTransaction(ctx context.Context, chainID *big.Int, call ContractCallType) (nonce uint64, err error)
 	// GetSubmissionStatus returns the status of a transaction and any metadata associated with it if it is complete.
 	GetSubmissionStatus(ctx context.Context, chainID *big.Int, nonce uint64) (status SubmissionStatus, err error)
+	// Address returns the address of the signer.
+	Address() common.Address
 }
 
 // txSubmitterImpl is the implementation of the transaction submitter.
@@ -665,4 +667,8 @@ func (t *txSubmitterImpl) getGasEstimate(ctx context.Context, chainClient client
 	return gasEstimate, nil
 }
 
+func (t *txSubmitterImpl) Address() common.Address {
+	return t.signer.Address()
+}
+
 var _ TransactionSubmitter = &txSubmitterImpl{}

go.work.sum

@@ -1638,6 +1638,7 @@ github.com/Azure/go-autorest/logger v0.2.1/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZ
 github.com/Azure/go-autorest/tracing v0.6.0 h1:TYi4+3m5t6K48TGI9AUdb+IzbnSxvnvUMfuitfgcfuo=
 github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU=
 github.com/BurntSushi/toml v1.2.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802 h1:1BDTz0u9nC3//pOCMdNH+CiXJVYJh5UQNCOBG7jbELc=
 github.com/ClickHouse/clickhouse-go v1.5.4 h1:cKjXeYLNWVJIx2J1K6H2CqyRmfwVJVY1OV1coaaFcI0=
 github.com/ClickHouse/clickhouse-go v1.5.4/go.mod h1:EaI/sW7Azgz9UATzd5ZdZHRUhHgv5+JMS9NSr2smCJI=
@@ -1993,6 +1994,7 @@ github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfc
 github.com/cpuguy83/dockercfg v0.3.1 h1:/FpZ+JaygUR/lZP2NlFI2DVfrOEMAIKP5wWEJdoYe9E=
 github.com/cpuguy83/dockercfg v0.3.1/go.mod h1:sugsbF4//dDlL/i+S+rtpIWp+5h0BHJHfjj5/jFyUJc=
 github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk=
+github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/crackcomm/go-gitignore v0.0.0-20170627025303-887ab5e44cc3 h1:HVTnpeuvF6Owjd5mniCL8DEXo7uYXdQEmOP4FJbV5tg=
 github.com/crackcomm/go-gitignore v0.0.0-20170627025303-887ab5e44cc3/go.mod h1:p1d6YEZWvFzEh4KLyvBcVSnrfNDDvK2zfK/4x2v/4pE=
 github.com/crate-crypto/go-ipa v0.0.0-20220523130400-f11357ae11c7 h1:6IrxszG5G+O7zhtkWxq6+unVvnrm1fqV2Pe+T95DUzw=

services/rfq/relayer/cmd/cmd.go

@@ -23,7 +23,7 @@
 	}
 
 	// commands
-	app.Commands = cli.Commands{runCommand}
+	app.Commands = cli.Commands{runCommand, withdrawCommand}
 	shellCommand := commandline.GenerateShellCommand(app.Commands)
 	app.Commands = append(app.Commands, shellCommand)
 	app.Action = shellCommand.Action

services/rfq/relayer/cmd/commands.go

@@ -4,9 +4,11 @@
 import (
 	"fmt"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/synapsecns/sanguine/core"
 	"github.com/synapsecns/sanguine/core/commandline"
 	"github.com/synapsecns/sanguine/core/metrics"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/relapi"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/service"
 	"github.com/urfave/cli/v2"
@@ -44,3 +46,79 @@
 		return nil
 	},
 }
+
+var relayerURLFlag = &cli.StringFlag{
+	Name:  "relayer-url",
+	Usage: "relayer url",
+}
+
+var chainIDFlag = &cli.StringFlag{
+	Name:  "chain-id",
+	Usage: "chain id",
+}
+
+var amountFlag = &cli.StringFlag{
+	Name:  "amount",
+	Usage: "amount",
+}
+
+var tokenAddressFlag = &cli.StringFlag{
+	Name:  "token-address",
+	Usage: "token address",
+}
+
+var toFlag = &cli.StringFlag{
+	Name:  "to",
+	Usage: "to",
+}
+
+// runCommand runs the rfq relayer.
+var withdrawCommand = &cli.Command{
+	Name:        "withdraw",
+	Description: "run the withdrawal tool",
+	Flags:       []cli.Flag{relayerURLFlag, chainIDFlag, amountFlag, tokenAddressFlag, toFlag, &commandline.LogLevel},
+	Action: func(c *cli.Context) (err error) {
+		if c.String(relayerURLFlag.Name) == "" {
+			return fmt.Errorf("relayer URL is required")
+		}
+
+		client := relapi.NewRelayerClient(metrics.Get(), c.String(relayerURLFlag.Name))
+		if err != nil {
+			return fmt.Errorf("could not create relayer: %w", err)
+		}
+
+		chainID := c.Uint(chainIDFlag.Name)
+		if chainID == 0 {
+			return fmt.Errorf("valid chain ID is required")
+		}
+
+		amount := c.String(amountFlag.Name)
+		if amount == "" {
+			return fmt.Errorf("amount is required")
+		}
+
+		tokenAddress := c.String(tokenAddressFlag.Name)
+		if !common.IsHexAddress(tokenAddress) {
+			return fmt.Errorf("valid token address is required")
+		}
+
+		to := c.String(toFlag.Name)
+		if !common.IsHexAddress(to) {
+			return fmt.Errorf("valid recipient address is required")
+		}
+
+		withdrawRequest := relapi.WithdrawRequest{
+			ChainID:      uint32(chainID),
+			Amount:       amount,
+			TokenAddress: common.HexToAddress(tokenAddress),
+			To:           common.HexToAddress(to),
+		}
+
+		_, err = client.Withdraw(c.Context, &withdrawRequest)
+		if err != nil {
+			return fmt.Errorf("could not start relayer: %w", err)
+		}
+
+		return nil
+	},
+}

services/rfq/relayer/relapi/client.go

@@ -17,6 +17,7 @@
 	GetQuoteRequestStatusByTxHash(ctx context.Context, hash string) (*GetQuoteRequestStatusResponse, error)
 	GetQuoteRequestStatusByTxID(ctx context.Context, hash string) (*GetQuoteRequestStatusResponse, error)
 	RetryTransaction(ctx context.Context, txhash string) (*GetTxRetryResponse, error)
+	Withdraw(ctx context.Context, req *WithdrawRequest) (*WithdrawResponse, error)
 }
 
 type relayerClient struct {
@@ -100,3 +101,24 @@
 
 	return &res, nil
 }
+
+// WithdrawResponse is the response for the withdraw request.
+type WithdrawResponse struct {
+	Nonce uint64 `json:"nonce"`
+}
+
+func (r *relayerClient) Withdraw(ctx context.Context, req *WithdrawRequest) (*WithdrawResponse, error) {
+	var res WithdrawResponse
+	resp, err := r.client.R().SetContext(ctx).
+		SetResult(&res).
+		SetBody(req).
+		Post(postWithdrawRoute)
+	if err != nil {
+		return nil, fmt.Errorf("failed to withdraw transaction: %w", err)
+	}
+	if resp.StatusCode() != http.StatusOK {
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode())
+	}
+
+	return &res, nil
+}

services/rfq/relayer/relapi/export_test.go

@@ -0,0 +1,11 @@
+package relapi
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
+)
+
+// TokenIDExists checks if a token ID exists in the config.
+func TokenIDExists(cfg relconfig.Config, tokenAddress common.Address, chainID int) bool {
+	return tokenIDExists(cfg, tokenAddress, chainID)
+}

services/rfq/relayer/relapi/handler.go

@@ -1,9 +1,18 @@
 package relapi
 
 import (
+	"encoding/json"
 	"fmt"
+	"math/big"
 	"net/http"
 
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/synapsecns/sanguine/ethergo/submitter"
+	"github.com/synapsecns/sanguine/services/rfq/contracts/ierc20"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/gin-gonic/gin"
@@ -13,15 +22,19 @@
 
 // Handler is the REST API handler.
 type Handler struct {
-	db     reldb.Service
-	chains map[uint32]*chain.Chain
+	db        reldb.Service
+	chains    map[uint32]*chain.Chain
+	cfg       relconfig.Config
+	submitter submitter.TransactionSubmitter
 }
 
 // NewHandler creates a new REST API handler.
-func NewHandler(db reldb.Service, chains map[uint32]*chain.Chain) *Handler {
+func NewHandler(db reldb.Service, chains map[uint32]*chain.Chain, cfg relconfig.Config, txSubmitter submitter.TransactionSubmitter) *Handler {
 	return &Handler{
-		db:     db, // Store the database connection in the handler
-		chains: chains,
+		db:        db, // Store the database connection in the handler
+		chains:    chains,
+		cfg:       cfg,
+		submitter: txSubmitter,
 	}
 }
 
@@ -107,14 +120,14 @@
 	}
 
 	chainID := quoteRequest.Transaction.DestChainId
-	chain, ok := h.chains[chainID]
+	chainHandler, 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 := chain.SubmitRelay(c, *quoteRequest)
+	nonce, gasAmount, err := chainHandler.SubmitRelay(c, *quoteRequest)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("could not submit relay: %s", err.Error())})
 		return
@@ -128,3 +141,148 @@
 	}
 	c.JSON(http.StatusOK, resp)
 }
+
+// Withdraw withdraws tokens from the relayer.
+//
+//nolint:cyclop
+func (h *Handler) Withdraw(c *gin.Context) {
+	var req WithdrawRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// validate the token address
+	if !tokenIDExists(h.cfg, req.TokenAddress, int(req.ChainID)) {
+		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("invalid token address %s for chain %d", req.TokenAddress.Hex(), req.ChainID)})
+		return
+	}
+
+	// validate the withdrawal address
+	if !toAddressIsWhitelisted(h.cfg, req.To) {
+		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("withdrawal address %s is not whitelisted", req.To.Hex())})
+		return
+	}
+
+	var nonce uint64
+	var err error
+
+	value, ok := new(big.Int).SetString(req.Amount, 10)
+	if !ok {
+		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("invalid amount %s", req.Amount)})
+		return
+	}
+
+	//nolint: nestif
+	if chain.IsGasToken(req.TokenAddress) {
+		nonce, err = h.submitter.SubmitTransaction(c, big.NewInt(int64(req.ChainID)), func(transactor *bind.TransactOpts) (tx *types.Transaction, err error) {
+			bc := bind.NewBoundContract(req.To, abi.ABI{}, h.chains[req.ChainID].Client, h.chains[req.ChainID].Client, h.chains[req.ChainID].Client)
+			if transactor.GasPrice != nil {
+				transactor.Value = value
+				// nolint: wrapcheck
+				return bc.Transfer(transactor)
+			}
+			signer, err := transactor.Signer(h.submitter.Address(), tx)
+			if err != nil {
+				return nil, fmt.Errorf("could not get signer: %w", err)
+			}
+			return signer, nil
+		})
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("could not submit transaction: %s", err.Error())})
+			return
+		}
+	} else {
+		erc20Contract, err := ierc20.NewIERC20(req.TokenAddress, h.chains[req.ChainID].Client)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("could not create erc20 contract: %s", err.Error())})
+			return
+		}
+
+		nonce, err = h.submitter.SubmitTransaction(c, big.NewInt(int64(req.ChainID)), func(transactor *bind.TransactOpts) (tx *types.Transaction, err error) {
+			// nolint: wrapcheck
+			return erc20Contract.Transfer(transactor, req.To, value)
+		})
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("could not submit transaction: %s", err.Error())})
+			return
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{"nonce": nonce})
+}
+
+// tokenIDExists checks if a token ID exists in the config.
+// note: this method assumes that SanitizeTokenID is a method of relconfig.Config
+func tokenIDExists(cfg relconfig.Config, tokenAddress common.Address, chainID int) bool {
+	for quotableToken := range cfg.QuotableTokens {
+		prospectiveChainID, prospectiveAddress, err := relconfig.DecodeTokenID(quotableToken)
+		if err != nil {
+			continue
+		}
+
+		if prospectiveChainID == chainID && prospectiveAddress == tokenAddress {
+			return true
+		}
+	}
+
+	return false
+}
+
+func toAddressIsWhitelisted(cfg relconfig.Config, to common.Address) bool {
+	for _, addr := range cfg.WithdrawalWhitelist {
+		if common.HexToAddress(addr) == to {
+			return true
+		}
+	}
+	return false
+}
+
+// WithdrawRequest is the request to withdraw tokens from the relayer.
+type WithdrawRequest struct {
+	// ChainID is the chain ID of the chain to withdraw from.
+	ChainID uint32 `json:"chain_id"`
+	// Amount is the amount to withdraw, in wei.
+	Amount string `json:"amount"`
+	// TokenAddress is the address of the token to withdraw.
+	TokenAddress common.Address `json:"token_address"`
+	// To is the address to withdraw to.
+	To common.Address `json:"to"`
+}
+
+// MarshalJSON handles JSON marshaling for WithdrawRequest.
+func (wr *WithdrawRequest) MarshalJSON() ([]byte, error) {
+	type Alias WithdrawRequest
+	// nolint: wrapcheck
+	return json.Marshal(&struct {
+		TokenAddress string `json:"token_address"`
+		To           string `json:"to"`
+		*Alias
+	}{
+		TokenAddress: wr.TokenAddress.Hex(),
+		To:           wr.To.Hex(),
+		Alias:        (*Alias)(wr),
+	})
+}
+
+// UnmarshalJSON has JSON unmarshalling for WithdrawRequest.
+func (wr *WithdrawRequest) UnmarshalJSON(data []byte) error {
+	type Alias WithdrawRequest
+	aux := &struct {
+		TokenAddress string `json:"token_address"`
+		To           string `json:"to"`
+		*Alias
+	}{
+		Alias: (*Alias)(wr),
+	}
+
+	if err := json.Unmarshal(data, aux); err != nil {
+		//nolint: wrapcheck
+		return err
+	}
+
+	wr.TokenAddress = common.HexToAddress(aux.TokenAddress)
+	wr.To = common.HexToAddress(aux.To)
+
+	return nil
+}