Relayer: CLI tool

cmd/native-relayer/cli/config.go

@@ -0,0 +1,49 @@
+package cli
+
+import "time"
+
+// Configuration struct
+type Config struct {
+	Native  NativeCfg  `mapstructure:"native"`
+	Ika     IkaCfg     `mapstructure:"ika"`
+	Btc     BitcoinCfg `mapstructure:"bitcoin"`
+	Relayer RelayerCfg `mapstructure:"relayer"`
+	DB      DBCfg      `mapstructure:"db"`
+}
+
+type NativeCfg struct {
+	RPC  string `mapstructure:"native_rpc"`
+	GRPC string `mapstructure:"native_grpc"`
+}
+
+type IkaCfg struct {
+	RPC              string `mapstructure:"ika_rpc"`
+	SignerMnemonic   string `mapstructure:"ika_signer_mnemonic"`
+	NativeLcPackage  string `mapstructure:"ika_native_lc_package"`
+	NativeLcModule   string `mapstructure:"ika_native_lc_module"`
+	NativeLcFunction string `mapstructure:"ika_native_lc_function"`
+	GasAcc           string `mapstructure:"ika_gas_acc"`
+	GasBudget        string `mapstructure:"ika_gas_budget"`
+}
+
+type BitcoinCfg struct {
+	RPCHost               string `mapstructure:"btc_rpc_host"`
+	RPCUser               string `mapstructure:"btc_rpc_user"`
+	RPCPass               string `mapstructure:"btc_rpc_pass"`
+	ConfirmationThreshold uint8  `mapstructure:"btc_confirmation_threshold"`
+	HTTPPostMode          bool   `mapstructure:"http_post_mode"`
+	DisableTLS            bool   `mapstructure:"disable_tls"`
+	Network               string `mapstructure:"network"`
+}
+
+type RelayerCfg struct {
+	ProcessTxsInterval   time.Duration `mapstructure:"process_txs_interval"`
+	ConfirmTxsInterval   time.Duration `mapstructure:"confirm_txs_interval"`
+	SignReqFetchInterval time.Duration `mapstructure:"sign_req_fetch_interval"`
+	SignReqFetchFrom     int           `mapstructure:"sign_req_fetch_from"`
+	SignReqFetchLimit    int           `mapstructure:"sign_req_fetch_limit"`
+}
+
+type DBCfg struct {
+	File string `mapstructure:"db_file"`
+}

cmd/native-relayer/cli/root.go

@@ -0,0 +1,35 @@
+package cli
+
+import (
+	"os"
+
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+)
+
+var (
+	configFile string
+	logLevel   string
+
+	rootCmd = &cobra.Command{
+		Use:   "relayer-cli",
+		Short: "CLI tool for managing the relayer",
+	}
+)
+
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		log.Error().Err(err).Msg("CLI execution failed")
+		os.Exit(1)
+	}
+}
+
+func init() {
+	rootCmd.PersistentFlags().StringVar(&configFile, "config", "", "Path to the config file")
+	rootCmd.PersistentFlags().StringVar(
+		&logLevel, "log-level",
+		"",
+		"Set the log level (trace, debug, info, warn, error, fatal, panic)",
+	)
+	rootCmd.AddCommand(startCmd)
+}

cmd/native-relayer/cli/start.go

@@ -0,0 +1,147 @@
+package cli
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+
+	"github.com/block-vision/sui-go-sdk/signer"
+	"github.com/block-vision/sui-go-sdk/sui"
+	"github.com/btcsuite/btcd/rpcclient"
+	"github.com/gonative-cc/relayer/dal"
+	"github.com/gonative-cc/relayer/env"
+	"github.com/gonative-cc/relayer/ika"
+	"github.com/gonative-cc/relayer/ika2btc"
+	"github.com/gonative-cc/relayer/native"
+	"github.com/gonative-cc/relayer/native2ika"
+	"github.com/gonative-cc/relayer/nbtc"
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+)
+
+var startCmd = &cobra.Command{
+	Use:   "start",
+	Short: "Starts the relayer",
+	Run: func(cmd *cobra.Command, args []string) {
+		lvl, err := cmd.Root().PersistentFlags().GetString("log-level")
+		if err != nil {
+			log.Error().Err(err).Msg("Error getting log level")
+			os.Exit(1)
+		}
+		logLvl, err := zerolog.ParseLevel(lvl)
+		if err != nil {
+			log.Error().Err(err).Msg("Error parsing log level")
+			os.Exit(1)
+		}
+		env.InitLogger(logLvl)
+		configFile, err := cmd.Root().PersistentFlags().GetString("config")
+		if err != nil {
+			log.Error().Err(err).Msg("Error getting config file path")
+			os.Exit(1)
+		}
+
+		config, err := loadConfig(configFile)
+		if err != nil {
+			log.Error().Err(err).Msg("Error loading config")
+			os.Exit(1)
+		}
+		db, err := dal.NewDB(config.DB.File)
+		if err != nil {
+			log.Error().Err(err).Msg("Error creating database")
+			os.Exit(1)
+		}
+		if err := db.InitDB(); err != nil {
+			log.Error().Err(err).Msg("Error initializing database")
+			os.Exit(1)
+		}
+		suiClient := sui.NewSuiClient(config.Ika.RPC).(*sui.Client)
+		if suiClient == nil {
+			log.Error().Err(err).Msg("Error creating Sui client")
+			os.Exit(1)
+		}
+		signer, err := signer.NewSignertWithMnemonic(config.Ika.SignerMnemonic)
+		if err != nil {
+			log.Error().Err(err).Msg("Error creating signer with mnemonic")
+			os.Exit(1)
+		}
+		ikaClient, err := ika.NewClient(
+			suiClient,
+			signer,
+			ika.SuiCtrCall{
+				Package:  config.Ika.NativeLcPackage,
+				Module:   config.Ika.NativeLcModule,
+				Function: config.Ika.NativeLcFunction,
+			},
+			ika.SuiCtrCall{
+				Package:  config.Ika.NativeLcPackage,
+				Module:   config.Ika.NativeLcModule,
+				Function: config.Ika.NativeLcFunction,
+			},
+			config.Ika.GasAcc,
+			config.Ika.GasBudget,
+		)
+		if err != nil {
+			log.Error().Err(err).Msg("Error creating IKA client")
+			os.Exit(1)
+		}
+		btcProcessor, err := ika2btc.NewProcessor(
+			rpcclient.ConnConfig{
+				Host:         config.Btc.RPCHost,
+				User:         config.Btc.RPCUser,
+				Pass:         config.Btc.RPCPass,
+				HTTPPostMode: config.Btc.HTTPPostMode,
+				DisableTLS:   config.Btc.DisableTLS,
+				Params:       config.Btc.Network,
+			},
+			config.Btc.ConfirmationThreshold,
+			db,
+		)
+		if err != nil {
+			log.Error().Err(err).Msg("Error creating Bitcoin processor")
+			os.Exit(1)
+		}
+		nativeProcessor := native2ika.NewProcessor(ikaClient, db)
+		// TODO: replace with the the real endpoint  once available
+		fetcher, err := native.NewMockAPISignRequestFetcher()
+		if err != nil {
+			log.Error().Err(err).Msg("Error creating SignReq fetcher ")
+			os.Exit(1)
+		}
+		relayer, err := nbtc.NewRelayer(
+			nbtc.RelayerConfig{
+				ProcessTxsInterval:   config.Relayer.ProcessTxsInterval,
+				ConfirmTxsInterval:   config.Relayer.ConfirmTxsInterval,
+				SignReqFetchInterval: config.Relayer.SignReqFetchInterval,
+				SignReqFetchFrom:     config.Relayer.SignReqFetchFrom,
+				SignReqFetchLimit:    config.Relayer.SignReqFetchLimit,
+			},
+			db,
+			nativeProcessor,
+			btcProcessor,
+			fetcher,
+		)
+		if err != nil {
+			log.Error().Err(err).Msg("Error creating relayer")
+			os.Exit(1)
+		}
+		var wg sync.WaitGroup
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if err := relayer.Start(context.Background()); err != nil {
+				log.Error().Err(err).Msg("Relayer encountered an error")
+			}
+		}()
+		c := make(chan os.Signal, 1)
+		signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+
+		<-c
+		log.Info().Msg("Stopping the relayer...")
+		relayer.Stop()
+		wg.Wait()
+		log.Info().Msg("Relayer stopped.")
+	},
+}

cmd/native-relayer/cli/utils.go

@@ -0,0 +1,32 @@
+package cli
+
+import (
+	"fmt"
+
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/viper"
+)
+
+func loadConfig(configFile string) (*Config, error) {
+	viper.SetConfigName("config")
+	viper.SetConfigType("yaml")
+	viper.AddConfigPath(".")
+	viper.AddConfigPath("$HOME/.native-relayer")
+	if configFile != "" {
+		viper.SetConfigFile(configFile)
+	}
+	if err := viper.ReadInConfig(); err != nil {
+		if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
+			return nil, fmt.Errorf("error reading config file: %w", err)
+		}
+	}
+	var config Config
+	if err := viper.Unmarshal(&config); err != nil {
+		return nil, fmt.Errorf("error unmarshalling config: %w", err)
+	}
+
+	log.Info().Msg("Loaded Configuration:")
+	log.Info().Interface("config", config).Msg("")
+
+	return &config, nil
+}

cmd/native-relayer/config.yaml

@@ -0,0 +1,33 @@
+# Relayer Configuration
+
+native:
+  native_rpc: "127.0.0.1:26657"  
+  native_grpc: "127.0.0.1:9090"       
+
+ika:
+  ika_rpc: "127.0.0.1:0001"          
+  ika_signer_mnemonic: "" 
+  ika_native_lc_package: ""                
+  ika_native_lc_module: ""               
+  ika_native_lc_function: ""  
+  ika_gas_acc: ""                            
+  ika_gas_budget: ""                         
+
+bitcoin:
+  btc_rpc_host: "your-bitcoin-rpc.com"           
+  btc_rpc_user: "your-bitcoin-rpc-user"          
+  btc_rpc_pass: "your-bitcoin-rpc-password"      
+  btc_confirmation_threshold: 6  
+  http_post_mode: true
+  disable_tls: false   
+  network: "testnet"        
+
+relayer:
+  process_txs_interval: 5s                      
+  confirm_txs_interval: 7s                   
+  sign_req_fetch_interval: 5s
+  sign_req_fetch_from: 0                      
+  sign_req_fetch_limit: 5                    
+
+db:
+  db_file: "relayer.db"     

cmd/native-relayer/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "github.com/gonative-cc/relayer/cmd/native-relayer/cli"
+
+func main() {
+	cli.Execute()
+}

nbtc/relayer.go

@@ -36,10 +36,9 @@ type Relayer struct {
 
 // RelayerConfig holds the configuration parameters for the Relayer.
 type RelayerConfig struct {
-	ProcessTxsInterval    time.Duration `json:"processTxsInterval"`
-	ConfirmTxsInterval    time.Duration `json:"confirmTxsInterval"`
-	SignReqFetchInterval  time.Duration `json:"signReqFetchInterval"`
-	ConfirmationThreshold uint8         `json:"confirmationThreshold"`
+	ProcessTxsInterval   time.Duration `json:"processTxsInterval"`
+	ConfirmTxsInterval   time.Duration `json:"confirmTxsInterval"`
+	SignReqFetchInterval time.Duration `json:"signReqFetchInterval"`
 	// ID of the first sign req that we want to fetch in
 	SignReqFetchFrom  int `json:"signReqFetchFrom"`
 	SignReqFetchLimit int `json:"signReqFetchLimit"`
@@ -82,10 +81,6 @@ func NewRelayer(
 		relayerConfig.SignReqFetchInterval = time.Second * 10
 	}
 
-	if relayerConfig.ConfirmationThreshold == 0 {
-		relayerConfig.ConfirmationThreshold = 6
-	}
-
 	return &Relayer{
 		db:                db,
 		nativeProcessor:   nativeProcessor,

nbtc/relayer_test.go

@@ -35,11 +35,10 @@ var btcClientConfig = rpcclient.ConnConfig{
 }
 
 var relayerConfig = RelayerConfig{
-	ProcessTxsInterval:    time.Second * 5,
-	ConfirmTxsInterval:    time.Second * 7,
-	ConfirmationThreshold: 6,
-	SignReqFetchFrom:      0,
-	SignReqFetchLimit:     5,
+	ProcessTxsInterval: time.Second * 5,
+	ConfirmTxsInterval: time.Second * 7,
+	SignReqFetchFrom:   0,
+	SignReqFetchLimit:  5,
 }
 
 // setupTestProcessor initializes the common dependencies