Merge branch 'main' into itaylevyofficial/101-run-status

# Conflicts:
#	.gitignore

.gitignore

@@ -1,7 +1,4 @@
 /.vscode
-*
-!*/
-!*.*
+build/
 *.exe
-\.*
-/.vscode
+/.idea

cmd/config/init/init.go

@@ -83,7 +83,7 @@ func InitCmd() *cobra.Command {
 		},
 		Args: cobra.ExactArgs(2),
 	}
-	utils.AddGlobalFlags(initCmd)
+
 	addFlags(initCmd)
 	return initCmd
 }

cmd/da-light-client/start/start.go

@@ -33,11 +33,11 @@ func Cmd() *cobra.Command {
 			utils.PrintInsufficientBalancesIfAny(insufficientBalances)
 			rpcEndpoint := cmd.Flag(rpcEndpointFlag).Value.String()
 			startDALCCmd := GetStartDACmd(rollappConfig, rpcEndpoint)
-			logFilePath := GetDALogFilePath(rollappConfig.Home)
+			logFilePath := utils.GetDALogFilePath(rollappConfig.Home)
 			utils.RunBashCmdAsync(startDALCCmd, printOutput, parseError, utils.WithLogging(logFilePath))
 		},
 	}
-	utils.AddGlobalFlags(runCmd)
+
 	addFlags(runCmd)
 	return runCmd
 }
@@ -84,7 +84,3 @@ func GetStartDACmd(rollappConfig utils.RollappConfig, rpcEndpoint string) *exec.
 		"--p2p.network", "arabica",
 	)
 }
-
-func GetDALogFilePath(home string) string {
-	return filepath.Join(home, consts.ConfigDirName.DALightNode, "light_client.log")
-}

cmd/keys/export/export.go

@@ -0,0 +1,60 @@
+package export
+
+import (
+	"fmt"
+	"github.com/dymensionxyz/roller/cmd/consts"
+	"github.com/dymensionxyz/roller/cmd/utils"
+	"github.com/spf13/cobra"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+var supportedKeys = []string{
+	consts.KeysIds.HubSequencer,
+	consts.KeysIds.RollappSequencer,
+}
+
+func Cmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use: "export <key-id>",
+		Short: fmt.Sprintf("Exports the private key of the given key id. The supported keys are %s",
+			strings.Join(supportedKeys, ", ")),
+		Run: func(cmd *cobra.Command, args []string) {
+			home := cmd.Flag(utils.FlagNames.Home).Value.String()
+			config, err := utils.LoadConfigFromTOML(home)
+			utils.PrettifyErrorIfExists(err)
+
+			keyID := args[0]
+			if keyID == consts.KeysIds.HubSequencer {
+				exportKeyCmd := getExportKeyCmdBinary(keyID, filepath.Join(home, consts.ConfigDirName.HubKeys),
+					consts.Executables.Dymension)
+				out, err := utils.ExecBashCommand(exportKeyCmd)
+				utils.PrettifyErrorIfExists(err)
+				fmt.Println(out.String())
+			} else if keyID == consts.KeysIds.RollappSequencer {
+				exportKeyCmd := getExportKeyCmdBinary(keyID, filepath.Join(home, consts.ConfigDirName.Rollapp),
+					config.RollappBinary)
+				out, err := utils.ExecBashCommand(exportKeyCmd)
+				utils.PrettifyErrorIfExists(err)
+				fmt.Println(out.String())
+			} else {
+				utils.PrettifyErrorIfExists(fmt.Errorf("invalid key id: %s. The supported keys are %s", keyID,
+					strings.Join(supportedKeys, ", ")))
+			}
+		},
+		Args: cobra.ExactArgs(1),
+	}
+
+	return cmd
+}
+
+func getExportKeyCmdBinary(keyID, keyringDir, binary string) *exec.Cmd {
+	flags := getExportKeyFlags(keyringDir)
+	cmdStr := fmt.Sprintf("yes | %s keys export %s %s", binary, keyID, flags)
+	return exec.Command("bash", "-c", cmdStr)
+}
+
+func getExportKeyFlags(keyringDir string) string {
+	return fmt.Sprintf("--keyring-backend test --keyring-dir %s --unarmored-hex --unsafe", keyringDir)
+}

cmd/keys/keys.go

@@ -1,6 +1,7 @@
 package keys
 
 import (
+	"github.com/dymensionxyz/roller/cmd/keys/export"
 	"github.com/dymensionxyz/roller/cmd/keys/list"
 	"github.com/spf13/cobra"
 )
@@ -11,5 +12,6 @@ func Cmd() *cobra.Command {
 		Short: "Commands for managing the roller different keys.",
 	}
 	cmd.AddCommand(list.Cmd())
+	cmd.AddCommand(export.Cmd())
 	return cmd
 }

cmd/keys/list/list.go

@@ -55,6 +55,6 @@ func Cmd() *cobra.Command {
 			utils.PrintAddresses(addresses)
 		},
 	}
-	utils.AddGlobalFlags(cmd)
+
 	return cmd
 }

cmd/register/register.go

@@ -38,7 +38,7 @@ func Cmd() *cobra.Command {
 			printRegisterOutput(rollappConfig)
 		},
 	}
-	utils.AddGlobalFlags(registerCmd)
+
 	return registerCmd
 }
 

cmd/relayer/start/create_ibc_channel.go

@@ -22,6 +22,13 @@ func createIBCChannelIfNeeded(rollappConfig utils.RollappConfig, logFileOption u
 		return "", err
 	}
 	if dstConnectionId == "" {
+		// Before setting up the connection, we need to call update clients
+		updateClientsCmd := getUpdateClientsCmd(rollappConfig)
+		fmt.Println("Updating clients...")
+		if err := utils.ExecBashCmdWithOSOutput(updateClientsCmd, logFileOption); err != nil {
+			return "", err
+		}
+
 		createConnectionCmd := getCreateConnectionCmd(rollappConfig)
 		fmt.Println("Creating connection...")
 		if err := utils.ExecBashCmdWithOSOutput(createConnectionCmd, logFileOption); err != nil {

cmd/relayer/start/start.go

@@ -27,7 +27,7 @@ func Start() *cobra.Command {
 			rollappConfig, err := utils.LoadConfigFromTOML(home)
 			VerifyRelayerBalances(rollappConfig)
 			utils.PrettifyErrorIfExists(err)
-			relayerLogFilePath := filepath.Join(home, consts.ConfigDirName.Relayer, "relayer.log")
+			relayerLogFilePath := utils.GetRelayerLogPath(rollappConfig)
 			logFileOption := utils.WithLogging(relayerLogFilePath)
 			srcChannelId, err := createIBCChannelIfNeeded(rollappConfig, logFileOption)
 			utils.PrettifyErrorIfExists(err)
@@ -39,7 +39,7 @@ func Start() *cobra.Command {
 			select {}
 		},
 	}
-	utils.AddGlobalFlags(relayerStartCmd)
+
 	return relayerStartCmd
 }
 

cmd/root.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"github.com/dymensionxyz/roller/cmd/run"
+	"github.com/dymensionxyz/roller/cmd/utils"
 	"os"
 
 	"github.com/dymensionxyz/roller/cmd/config"
@@ -38,4 +39,5 @@ func init() {
 	rootCmd.AddCommand(relayer.Cmd())
 	rootCmd.AddCommand(keys.Cmd())
 	rootCmd.AddCommand(run.Cmd())
+	utils.AddGlobalFlags(rootCmd)
 }

cmd/run/run.go

@@ -9,7 +9,6 @@ import (
 	"github.com/dymensionxyz/roller/cmd/utils"
 	"github.com/spf13/cobra"
 	"os/exec"
-	"path/filepath"
 	"sync"
 )
 
@@ -41,7 +40,7 @@ func Cmd() *cobra.Command {
 			logger.Println("killed them")
 		},
 	}
-	utils.AddGlobalFlags(cmd)
+
 	return cmd
 }
 
@@ -55,15 +54,14 @@ func getStartRelayerCmd(config utils.RollappConfig) *exec.Cmd {
 }
 
 func runDaWithRestarts(rollappConfig utils.RollappConfig, serviceConfig utils.ServiceConfig) {
-	daLogFilePath := da_start.GetDALogFilePath(rollappConfig.Home)
+	daLogFilePath := utils.GetDALogFilePath(rollappConfig.Home)
 	startDALCCmd := da_start.GetStartDACmd(rollappConfig, consts.DefaultCelestiaRPC)
 	utils.RunServiceWithRestart(startDALCCmd, serviceConfig, utils.WithLogging(daLogFilePath))
 }
 
 func runSequencerWithRestarts(rollappConfig utils.RollappConfig, serviceConfig utils.ServiceConfig) {
 	startRollappCmd := sequnecer_start.GetStartRollappCmd(rollappConfig, consts.DefaultDALCRPC)
-	utils.RunServiceWithRestart(startRollappCmd, serviceConfig, utils.WithLogging(
-		filepath.Join(rollappConfig.Home, consts.ConfigDirName.Rollapp, "rollapp.log")))
+	utils.RunServiceWithRestart(startRollappCmd, serviceConfig, utils.WithLogging(utils.GetSequencerLogPath(rollappConfig)))
 }
 
 func verifyBalances(rollappConfig utils.RollappConfig) {

cmd/run/services_info.go

@@ -0,0 +1,23 @@
+package run
+
+import (
+	"github.com/dymensionxyz/roller/cmd/utils"
+	"github.com/gizak/termui/v3"
+	"github.com/gizak/termui/v3/widgets"
+)
+
+func getServicesInfo(rollappConfig utils.RollappConfig, termWidth int) *widgets.Table {
+	table := widgets.NewTable()
+	table.RowStyles[0] = termui.NewStyle(termui.ColorWhite, termui.ColorClear, termui.ModifierBold)
+	table.SetRect(0, 13, termWidth, 22)
+	table.Title = "Services Info"
+	table.FillRow = true
+	table.ColumnWidths = []int{termWidth / 6, termWidth / 2, termWidth / 3}
+	table.Rows = [][]string{
+		{"Name", "Log File", "Ports"},
+		{"Sequencer", utils.GetSequencerLogPath(rollappConfig), "26657, 8545, 1317"},
+		{"Relayer", utils.GetRelayerLogPath(rollappConfig), ""},
+		{"DA Light Client", utils.GetDALogFilePath(rollappConfig.Home), "26659"},
+	}
+	return table
+}

cmd/run/services_status.go

@@ -69,20 +69,20 @@ func PrintServicesStatus(rollappConfig utils.RollappConfig) {
 	termWidth, _ := ui.TerminalDimensions()
 
 	p := buildUIParagraph(termWidth)
-	table := buildUITable(termWidth)
+	servicesStatusTable := buildUITable(termWidth)
+	servicesInfoTable := getServicesInfo(rollappConfig, termWidth)
 	serviceData := getInitialServiceData()
 
-	updateUITable(serviceData, table)
-	ui.Render(p, table)
+	updateUITable(serviceData, servicesStatusTable)
+	ui.Render(p, servicesStatusTable, servicesInfoTable)
 
 	events := ui.PollEvents()
 	ticker := time.NewTicker(time.Second * 1).C
 
 	config := ServiceStatusConfig{
 		rollappConfig: rollappConfig,
 		logger:        logger,
-		table:         table,
-		p:             p,
+		table:         servicesStatusTable,
 	}
 
 	eventLoop(events, ticker, config)
@@ -102,10 +102,9 @@ func eventLoop(events <-chan ui.Event, ticker <-chan time.Time, config ServiceSt
 				config.logger.Printf("Error: failed to fetch service data: %v", err)
 			} else {
 				config.logger.Printf("Fetched services data successfully %s", serviceData)
-
 			}
 			updateUITable(serviceData, config.table)
-			ui.Render(config.p, config.table)
+			ui.Render(config.table)
 		}
 	}
 }
@@ -114,5 +113,4 @@ type ServiceStatusConfig struct {
 	rollappConfig utils.RollappConfig
 	logger        *log.Logger
 	table         *widgets.Table
-	p             *widgets.Paragraph
 }

cmd/sequencer/start/start.go

@@ -29,11 +29,11 @@ func StartCmd() *cobra.Command {
 			utils.PrintInsufficientBalancesIfAny(sequencerInsufficientAddrs)
 			LightNodeEndpoint := cmd.Flag(FlagNames.DAEndpoint).Value.String()
 			startRollappCmd := GetStartRollappCmd(rollappConfig, LightNodeEndpoint)
-			utils.RunBashCmdAsync(startRollappCmd, printOutput, parseError, utils.WithLogging(
-				filepath.Join(rollappConfig.Home, consts.ConfigDirName.Rollapp, "rollapp.log")))
+			utils.RunBashCmdAsync(startRollappCmd, printOutput, parseError,
+				utils.WithLogging(utils.GetSequencerLogPath(rollappConfig)))
 		},
 	}
-	utils.AddGlobalFlags(runCmd)
+
 	runCmd.Flags().StringP(FlagNames.DAEndpoint, "", consts.DefaultDALCRPC,
 		"The data availability light node endpoint.")
 	return runCmd
@@ -90,7 +90,5 @@ func GetStartRollappCmd(rollappConfig utils.RollappConfig, lightNodeEndpoint str
 		"--log_level", "info",
 		"--max-log-size", "2000",
 	)
-
-	fmt.Println(cmd.String())
 	return cmd
 }

cmd/utils/global_flags.go

@@ -8,7 +8,8 @@ import (
 )
 
 func AddGlobalFlags(command *cobra.Command) {
-	command.Flags().StringP(FlagNames.Home, "", GetRollerRootDir(), "The directory of the roller config files")
+	command.PersistentFlags().StringP(
+		FlagNames.Home, "", GetRollerRootDir(), "The directory of the roller config files")
 }
 
 var FlagNames = struct {

cmd/utils/log.go

@@ -1,6 +1,7 @@
 package utils
 
 import (
+	"github.com/dymensionxyz/roller/cmd/consts"
 	"gopkg.in/natefinch/lumberjack.v2"
 	"io"
 	"log"
@@ -32,3 +33,15 @@ func GetLogger(filepath string) *log.Logger {
 	logger := log.New(multiWriter, "", log.LstdFlags)
 	return logger
 }
+
+func GetSequencerLogPath(rollappConfig RollappConfig) string {
+	return filepath.Join(rollappConfig.Home, consts.ConfigDirName.Rollapp, "rollapp.log")
+}
+
+func GetRelayerLogPath(config RollappConfig) string {
+	return filepath.Join(config.Home, consts.ConfigDirName.Relayer, "relayer.log")
+}
+
+func GetDALogFilePath(home string) string {
+	return filepath.Join(home, consts.ConfigDirName.DALightNode, "light_client.log")
+}

test/config/init/init_test.go

@@ -1,7 +1,6 @@
 package initconfig_test
 
 import (
-	"fmt"
 	"io/ioutil"
 	"path/filepath"
 	"testing"
@@ -39,13 +38,13 @@ func TestInitCmd(t *testing.T) {
 			assert := assert.New(t)
 			tempDir, err := ioutil.TempDir(os.TempDir(), "test")
 			tempDir = filepath.Join(tempDir, ".roller")
-			fmt.Println(tc.name, tempDir)
 			assert.NoError(err)
-			//defer func() {
-			//	err := os.RemoveAll(tempDir)
-			//	assert.NoError(err)
-			//}()
+			defer func() {
+				err := os.RemoveAll(tempDir)
+				assert.NoError(err)
+			}()
 			initCmd := initconfig.InitCmd()
+			utils.AddGlobalFlags(initCmd)
 			denom := "udym"
 			rollappID := "mars_1-1"
 			initCmd.SetArgs(append([]string{