synapsecns/sanguine

// Package cmd provides the command line interface for the RFQ relayer service
package cmd

import (
    "context"
    "fmt"
    "math/big"
    "time"

    "github.com/charmbracelet/huh/spinner"
    "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/core/retry"
    "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"
)

var configFlag = &cli.StringFlag{
    Name:      "config",
    Usage:     "path to the config file",
    TakesFile: true,
}

// runCommand runs the rfq relayer.
var runCommand = &cli.Command{
    Name:        "run",
    Description: "run the relayer",
    Flags:       []cli.Flag{configFlag, &commandline.LogLevel},
    Action: func(c *cli.Context) (err error) {
        commandline.SetLogLevel(c)

        metricsProvider := metrics.Get()

        cfg, err := relconfig.LoadConfig(core.ExpandOrReturnPath(c.String(configFlag.Name)))
        if err != nil {
            return fmt.Errorf("could not read config file: %w", err)
        }

        relayer, err := service.NewRelayer(c.Context, metricsProvider, cfg)
        if err != nil {
            return fmt.Errorf("could not create relayer: %w", err)
        }

        err = relayer.Start(c.Context)
        if err != nil {
            return fmt.Errorf("could not start relayer: %w", err)
        }
        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 := big.NewInt(c.Int64(chainIDFlag.Name))
        if chainID.Cmp(big.NewInt(0)) == 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.Uint64()),
            Amount:       amount,
            TokenAddress: common.HexToAddress(tokenAddress),
            To:           common.HexToAddress(to),
        }
        res, err := client.Withdraw(c.Context, &withdrawRequest)
        if err != nil {
            return fmt.Errorf("could not start relayer: %w", err)
        }

        var errClient error
        var status *relapi.TxHashByNonceResponse

        ctx, cancel := context.WithTimeout(c.Context, 30*time.Second)
        defer cancel()

        action := func() {
            err = retry.WithBackoff(ctx, func(_ context.Context) error {
                status, err = client.GetTxHashByNonce(
                    c.Context,
                    &relapi.GetTxByNonceRequest{
                        ChainID: uint32(chainID.Uint64()),
                        Nonce:   res.Nonce,
                    })
                if err != nil {
                    errClient = err
                    return fmt.Errorf("could not get withdrawal tx hash: %w", err)
                }
                return nil
            }, retry.WithMaxTotalTime(1*time.Minute))

            if err != nil {
                return
            }
        }

        err = spinner.New().
            Title("Getting withdrawal tx hash...").
            Action(action).Run()

        if err != nil {
            return fmt.Errorf("could not get withdrawal tx hash: %w", err)
        }
        if errClient != nil {
            return fmt.Errorf("client error: could not get withdrawal tx hash: %w", errClient)
        }

        fmt.Printf("Withdraw Tx Hash: %s\n", status.Hash)

        return nil
    },
}