Merge pull request #127 from initia-labs/feat/keyfile-address

Benzbeeb · web-flow · commit 1c3e5c46405f · 2025-02-04T17:41:53.000+07:00
feat: add address to keyfile structs
diff --git a/cmd/opinit_bots.go b/cmd/opinit_bots.go
@@ -171,10 +171,10 @@ func handleWithConfig(cmd *cobra.Command, userHome, opInitHome, configPath, keyF
 		return err
 	}
 
-	var keyFile *weaveio.KeyFile
+	var keyFile weaveio.KeyFile
 	if isGenerateKeyFile {
 		keyPath := filepath.Join(userHome, common.WeaveDataDirectory, fmt.Sprintf("%s.%s.keyfile", common.OpinitGeneratedKeyFilename, botName))
-		keyFile, err = opinit_bots.GenerateMnemonicKeyfile(botName)
+		keyFile, err = opinit_bots.GenerateMnemonicKeyfile(fileData, botName)
 		if err != nil {
 			return fmt.Errorf("error generating keyfile: %v", err)
 		}
@@ -208,14 +208,14 @@ func handleWithConfig(cmd *cobra.Command, userHome, opInitHome, configPath, keyF
 }
 
 // readAndUnmarshalKeyFile read and unmarshal the key file into the KeyFile struct
-func readAndUnmarshalKeyFile(keyFilePath string) (*weaveio.KeyFile, error) {
+func readAndUnmarshalKeyFile(keyFilePath string) (weaveio.KeyFile, error) {
 	fileData, err := os.ReadFile(keyFilePath)
 	if err != nil {
 		return nil, err
 	}
 
-	keyFile := &weaveio.KeyFile{}
-	err = json.Unmarshal(fileData, keyFile)
+	keyFile := weaveio.KeyFile{}
+	err = json.Unmarshal(fileData, &keyFile)
 	return keyFile, err
 }
 
@@ -239,7 +239,7 @@ func handleExistingOpInitHome(opInitHome string, botName string, force bool) err
 }
 
 // initializeBotWithConfig initialize a bot based on the provided config
-func initializeBotWithConfig(cmd *cobra.Command, fileData []byte, keyFile *weaveio.KeyFile, opInitHome, userHome, botName string) error {
+func initializeBotWithConfig(cmd *cobra.Command, fileData []byte, keyFile weaveio.KeyFile, opInitHome, userHome, botName string) error {
 	var err error
 
 	switch botName {
@@ -345,9 +345,9 @@ func OPInitBotsInitCommand() *cobra.Command {
 	initCmd.Flags().String(FlagMinitiaHome, filepath.Join(homeDir, common.MinitiaDirectory), "Rollup application directory to fetch artifacts from if existed")
 	initCmd.Flags().String(FlagOPInitHome, filepath.Join(homeDir, common.OPinitDirectory), "OPInit bots home directory")
 	initCmd.Flags().String(FlagWithConfig, "", "Bypass the interactive setup and initialize the bot by providing a path to a config file. Either --key-file or --generate-key-file has to be specified")
-	initCmd.Flags().String(FlagKeyFile, "", "Use this flag to generate the bot keys. Cannot be specified together with --key-file")
+	initCmd.Flags().String(FlagKeyFile, "", "Path to key-file.json. Cannot be specified together with --generate-key-file")
 	initCmd.Flags().BoolP(FlagForce, "f", false, "Force the setup by deleting the existing .opinit directory if it exists")
-	initCmd.Flags().BoolP(FlagGenerateKeyFile, "", false, "Path to key-file.json. Cannot be specified together with --generate-key-file")
+	initCmd.Flags().BoolP(FlagGenerateKeyFile, "", false, "Use this flag to generate the bot keys. Cannot be specified together with --key-file")
 
 	return initCmd
 }
diff --git a/io/keyfile.go b/io/keyfile.go
@@ -4,24 +4,67 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+
+	"github.com/initia-labs/weave/crypto"
 )
 
-type KeyFile map[string]string
+type Key struct {
+	Address  string `json:"address"`
+	Mnemonic string `json:"mnemonic"`
+}
+
+func NewKey(address, mnemonic string) *Key {
+	return &Key{
+		Address:  address,
+		Mnemonic: mnemonic,
+	}
+}
+
+func GenerateKey(hrp string) (*Key, error) {
+	mnemonic, err := crypto.GenerateMnemonic()
+	if err != nil {
+		return nil, fmt.Errorf("failed to generate mnemonic: %w", err)
+	}
+
+	address, err := crypto.MnemonicToBech32Address(hrp, mnemonic)
+	if err != nil {
+		return nil, fmt.Errorf("failed to derive address: %w", err)
+	}
+
+	return &Key{
+		Mnemonic: mnemonic,
+		Address:  address,
+	}, nil
+}
+
+func RecoverKey(hrp, mnemonic string) (*Key, error) {
+	address, err := crypto.MnemonicToBech32Address(hrp, mnemonic)
+	if err != nil {
+		return nil, fmt.Errorf("failed to derive address: %w", err)
+	}
+
+	return &Key{
+		Mnemonic: mnemonic,
+		Address:  address,
+	}, nil
+}
+
+type KeyFile map[string]*Key
 
-func NewKeyFile() *KeyFile {
+func NewKeyFile() KeyFile {
 	kf := make(KeyFile)
-	return &kf
+	return kf
 }
 
-func (k *KeyFile) AddMnemonic(name, mnemonic string) {
-	(*k)[name] = mnemonic
+func (k KeyFile) AddKey(name string, key *Key) {
+	k[name] = key
 }
 
-func (k *KeyFile) GetMnemonic(name string) string {
-	return (*k)[name]
+func (k KeyFile) GetMnemonic(name string) string {
+	return k[name].Mnemonic
 }
 
-func (k *KeyFile) Write(filePath string) error {
+func (k KeyFile) Write(filePath string) error {
 	data, err := json.MarshalIndent(k, "", "  ")
 	if err != nil {
 		return fmt.Errorf("error marshaling KeyFile to JSON: %w", err)
@@ -31,7 +74,7 @@ func (k *KeyFile) Write(filePath string) error {
 }
 
 // Load tries to load an existing key file into the struct if the file exists
-func (k *KeyFile) Load(filePath string) error {
+func (k KeyFile) Load(filePath string) error {
 	if _, err := os.Stat(filePath); os.IsNotExist(err) {
 		return nil
 	}
@@ -41,7 +84,7 @@ func (k *KeyFile) Load(filePath string) error {
 		return fmt.Errorf("error reading file: %w", err)
 	}
 
-	err = json.Unmarshal(data, k)
+	err = json.Unmarshal(data, &k)
 	if err != nil {
 		return fmt.Errorf("error unmarshaling JSON: %w", err)
 	}
diff --git a/models/opinit_bots/config.go b/models/opinit_bots/config.go
@@ -1,9 +1,9 @@
 package opinit_bots
 
 import (
+	"encoding/json"
 	"fmt"
 
-	"github.com/initia-labs/weave/crypto"
 	weaveio "github.com/initia-labs/weave/io"
 )
 
@@ -59,45 +59,51 @@ type ExecutorConfig struct {
 	DisableDeleteFutureWithdrawal bool         `json:"disable_delete_future_withdrawal"`
 }
 
-func GenerateMnemonicKeyfile(botName string) (*weaveio.KeyFile, error) {
+func GenerateMnemonicKeyfile(rawConfig []byte, botName string) (weaveio.KeyFile, error) {
 	keyFile := weaveio.NewKeyFile()
 
 	switch botName {
 	case "executor":
-		bridgeExecutor, err := crypto.GenerateMnemonic()
+		var config ExecutorConfig
+		err := json.Unmarshal(rawConfig, &config)
 		if err != nil {
-			return &weaveio.KeyFile{}, fmt.Errorf("failed to generate bridge executor mnemonic: %w", err)
+			return nil, fmt.Errorf("failed to unmarshal executor config: %v", err)
 		}
-		keyFile.AddMnemonic(BridgeExecutorKeyName, bridgeExecutor)
 
-		outputSubmitter, err := crypto.GenerateMnemonic()
+		bridgeExecutor, err := weaveio.GenerateKey("init")
 		if err != nil {
-			return &weaveio.KeyFile{}, fmt.Errorf("failed to generate output submitter mnemonic: %w", err)
+			return nil, fmt.Errorf("failed to generate bridge executor mnemonic: %w", err)
 		}
-		keyFile.AddMnemonic(OutputSubmitterKeyName, outputSubmitter)
+		keyFile.AddKey(BridgeExecutorKeyName, bridgeExecutor)
 
-		batchSubmitter, err := crypto.GenerateMnemonic()
+		outputSubmitter, err := weaveio.GenerateKey("init")
 		if err != nil {
-			return &weaveio.KeyFile{}, fmt.Errorf("failed to generate batch submitter mnemonic: %w", err)
+			return nil, fmt.Errorf("failed to generate output submitter mnemonic: %w", err)
 		}
-		keyFile.AddMnemonic(BatchSubmitterKeyName, batchSubmitter)
+		keyFile.AddKey(OutputSubmitterKeyName, outputSubmitter)
 
-		oracleBridgeExecutor, err := crypto.GenerateMnemonic()
+		batchSubmitter, err := weaveio.GenerateKey(config.DANode.Bech32Prefix)
 		if err != nil {
-			return &weaveio.KeyFile{}, fmt.Errorf("failed to generate oracle bridge executor mnemonic: %w", err)
+			return nil, fmt.Errorf("failed to generate batch submitter mnemonic: %w", err)
 		}
-		keyFile.AddMnemonic(OracleBridgeExecutorKeyName, oracleBridgeExecutor)
+		keyFile.AddKey(BatchSubmitterKeyName, batchSubmitter)
+
+		oracleBridgeExecutor, err := weaveio.GenerateKey("init")
+		if err != nil {
+			return nil, fmt.Errorf("failed to generate oracle bridge executor mnemonic: %w", err)
+		}
+		keyFile.AddKey(OracleBridgeExecutorKeyName, oracleBridgeExecutor)
 
 		return keyFile, nil
 	case "challenger":
-		challenger, err := crypto.GenerateMnemonic()
+		challenger, err := weaveio.GenerateKey("init")
 		if err != nil {
-			return &weaveio.KeyFile{}, fmt.Errorf("failed to generate challenger mnemonic: %w", err)
+			return nil, fmt.Errorf("failed to generate challenger mnemonic: %w", err)
 		}
-		keyFile.AddMnemonic(ChallengerKeyName, challenger)
+		keyFile.AddKey(ChallengerKeyName, challenger)
 
 		return keyFile, nil
 	default:
-		return &weaveio.KeyFile{}, fmt.Errorf("unsupported bot name: %s", botName)
+		return nil, fmt.Errorf("unsupported bot name: %s", botName)
 	}
 }
diff --git a/models/opinit_bots/init.go b/models/opinit_bots/init.go
@@ -1099,6 +1099,31 @@ func WaitStartingInitBot(ctx context.Context) tea.Cmd {
 			}
 		}
 
+		keyFilePath, err := weavecontext.GetOPInitKeyFileJson(ctx)
+		if err != nil {
+			return ui.NonRetryableErrorLoading{Err: fmt.Errorf("failed to get key file path for OPinit: %w", err)}
+		}
+
+		keyFile := io.NewKeyFile()
+		err = keyFile.Load(keyFilePath)
+		if err != nil {
+			return ui.NonRetryableErrorLoading{Err: fmt.Errorf("failed to load key file for OPinit: %w", err)}
+		}
+
+		for _, botName := range BotNames {
+			if res, ok := state.SetupOpinitResponses[botName]; ok {
+				keyInfo := strings.Split(res, "\n")
+				address := strings.Split(keyInfo[0], ": ")
+				mnemonic := keyInfo[1]
+				keyFile.AddKey(string(BotNameToKeyName[botName]), io.NewKey(address[1], mnemonic))
+			}
+		}
+
+		err = keyFile.Write(keyFilePath)
+		if err != nil {
+			return ui.NonRetryableErrorLoading{Err: fmt.Errorf("failed to write key file: %w", err)}
+		}
+
 		if state.InitExecutorBot {
 			srv, err := service.NewService(service.OPinitExecutor)
 			if err != nil {
@@ -1345,30 +1370,6 @@ func (m *SetupOPInitBotsMissingKey) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return model, nil
 		}
 
-		keyFilePath, err := weavecontext.GetOPInitKeyFileJson(m.Ctx)
-		if err != nil {
-			return m, m.HandlePanic(fmt.Errorf("failed to get key file path for OPinit: %w", err))
-		}
-
-		keyFile := io.NewKeyFile()
-		err = keyFile.Load(keyFilePath)
-		if err != nil {
-			return m, m.HandlePanic(fmt.Errorf("failed to load key file for OPinit: %w", err))
-		}
-
-		for _, botName := range BotNames {
-			if res, ok := state.SetupOpinitResponses[botName]; ok {
-				keyInfo := strings.Split(res, "\n")
-				mnemonic := keyInfo[1]
-				keyFile.AddMnemonic(string(BotNameToKeyName[botName]), mnemonic)
-			}
-		}
-
-		err = keyFile.Write(keyFilePath)
-		if err != nil {
-			return m, m.HandlePanic(fmt.Errorf("failed to write key file: %w", err))
-		}
-
 		switch msg := msg.(type) {
 		case tea.KeyMsg:
 			if msg.String() == "enter" {
@@ -1451,7 +1452,7 @@ func WaitSetupOPInitBotsMissingKey(ctx context.Context) tea.Cmd {
 	}
 }
 
-func InitializeExecutorWithConfig(config ExecutorConfig, keyFile *io.KeyFile, opInitHome, userHome string) error {
+func InitializeExecutorWithConfig(config ExecutorConfig, keyFile io.KeyFile, opInitHome, userHome string) error {
 	binaryPath, err := ensureOPInitBotsBinary(userHome)
 	if err != nil {
 		return err
@@ -1524,7 +1525,7 @@ func InitializeExecutorWithConfig(config ExecutorConfig, keyFile *io.KeyFile, op
 	return nil
 }
 
-func InitializeChallengerWithConfig(config ChallengerConfig, keyFile *io.KeyFile, opInitHome, userHome string) error {
+func InitializeChallengerWithConfig(config ChallengerConfig, keyFile io.KeyFile, opInitHome, userHome string) error {
 	binaryPath, err := ensureOPInitBotsBinary(userHome)
 	if err != nil {
 		return err
diff --git a/models/opinit_bots/setup.go b/models/opinit_bots/setup.go
@@ -468,8 +468,9 @@ func (m *SetupOPInitBots) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 		for botName, res := range state.SetupOpinitResponses {
 			keyInfo := strings.Split(res, "\n")
+			address := strings.Split(keyInfo[0], ": ")
 			mnemonic := keyInfo[1]
-			keyFile.AddMnemonic(string(BotNameToKeyName[botName]), mnemonic)
+			keyFile.AddKey(string(BotNameToKeyName[botName]), io.NewKey(address[1], mnemonic))
 		}
 
 		err = keyFile.Write(keyFilePath)
diff --git a/models/relayer/constants.go b/models/relayer/constants.go
@@ -9,4 +9,6 @@ const (
 
 	DefaultL1RelayerBalance = "1000000"
 	DefaultL2RelayerBalance = "1000000"
+	DefaultL1RelayerKeyName = "weave_l1_relayer"
+	DefaultL2RelayerKeyName = "weave_l2_relayer"
 )
diff --git a/models/relayer/init.go b/models/relayer/init.go
@@ -617,10 +617,19 @@ func (m *KeysMnemonicDisplayInput) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	if done {
 		state := weavecontext.PushPageAndGetState[State](m)
 
+		l1RelayerKey, err := weaveio.RecoverKey("init", state.l1RelayerMnemonic)
+		if err != nil {
+			return m, m.HandlePanic(fmt.Errorf("cannot recover l1 relayer key: %w", err))
+		}
+		l2RelayerKey, err := weaveio.RecoverKey("init", state.l2RelayerMnemonic)
+		if err != nil {
+			return m, m.HandlePanic(fmt.Errorf("cannot recover l2 relayer key: %w", err))
+		}
+
 		keyFile := weaveio.NewKeyFile()
-		keyFile.AddMnemonic("weave_l1_relayer", state.l1RelayerMnemonic)
-		keyFile.AddMnemonic("weave_l2_relayer", state.l2RelayerMnemonic)
-		err := keyFile.Write(m.keyFilePath)
+		keyFile.AddKey(DefaultL1RelayerKeyName, l1RelayerKey)
+		keyFile.AddKey(DefaultL2RelayerKeyName, l2RelayerKey)
+		err = keyFile.Write(m.keyFilePath)
 		if err != nil {
 			return m, m.HandlePanic(fmt.Errorf("failed to write key file: %w", err))
 		}
@@ -2735,24 +2744,35 @@ func (m *AddChallengerKeyToRelayer) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if err != nil {
 				return m, m.HandlePanic(err)
 			}
-			relayerKey, err := cosmosutils.RecoverAndReplaceHermesKey(state.hermesBinaryPath, l1ChainId, state.minitiaConfig.SystemKeys.Challenger.Mnemonic)
+			l1RelayerKey, err := cosmosutils.RecoverAndReplaceHermesKey(state.hermesBinaryPath, l1ChainId, state.minitiaConfig.SystemKeys.Challenger.Mnemonic)
 			if err != nil {
 				return m, m.HandlePanic(err)
 			}
-			state.l1RelayerAddress = relayerKey.Address
-			state.l1RelayerMnemonic = relayerKey.Mnemonic
+			state.l1RelayerAddress = l1RelayerKey.Address
+			state.l1RelayerMnemonic = l1RelayerKey.Mnemonic
 
 			l2ChainId, err := GetL2ChainId(m.Ctx)
 			if err != nil {
 				return m, m.HandlePanic(err)
 			}
-			relayerKey, err = cosmosutils.RecoverAndReplaceHermesKey(state.hermesBinaryPath, l2ChainId, state.minitiaConfig.SystemKeys.Challenger.Mnemonic)
+			l2RelayerKey, err := cosmosutils.RecoverAndReplaceHermesKey(state.hermesBinaryPath, l2ChainId, state.minitiaConfig.SystemKeys.Challenger.Mnemonic)
 			if err != nil {
 				return m, m.HandlePanic(err)
 			}
 
-			state.l2RelayerAddress = relayerKey.Address
-			state.l2RelayerMnemonic = relayerKey.Mnemonic
+			state.l2RelayerAddress = l2RelayerKey.Address
+			state.l2RelayerMnemonic = l2RelayerKey.Mnemonic
+
+			userHome, _ := os.UserHomeDir()
+			hermesKeyFile := filepath.Join(userHome, common.HermesKeyFileJson)
+
+			keyFile := weaveio.NewKeyFile()
+			keyFile.AddKey(DefaultL1RelayerKeyName, weaveio.NewKey(l1RelayerKey.Address, l1RelayerKey.Mnemonic))
+			keyFile.AddKey(DefaultL2RelayerKeyName, weaveio.NewKey(l2RelayerKey.Address, l2RelayerKey.Mnemonic))
+			err = keyFile.Write(hermesKeyFile)
+			if err != nil {
+				return m, m.HandlePanic(fmt.Errorf("failed to write key file: %w", err))
+			}
 
 			state.weave.PushPreviousResponse(getRelayerSetSuccessMessage())
 			return NewTerminalState(weavecontext.SetCurrentState(m.Ctx, state)), tea.Quit

Original file line number	Diff line number	Diff line change
`@@ -468,8 +468,9 @@ func (m *SetupOPInitBots) Update(msg tea.Msg) (tea.Model, tea.Cmd) {`
`468`	`468`
`469`	`469`	`for botName, res := range state.SetupOpinitResponses {`
`470`	`470`	`keyInfo := strings.Split(res, "\n")`
	`471`	`+ address := strings.Split(keyInfo[0], ": ")`
`471`	`472`	`mnemonic := keyInfo[1]`
`472`		`- keyFile.AddMnemonic(string(BotNameToKeyName[botName]), mnemonic)`
	`473`	`+ keyFile.AddKey(string(BotNameToKeyName[botName]), io.NewKey(address[1], mnemonic))`
`473`	`474`	`}`
`474`	`475`
`475`	`476`	`err = keyFile.Write(keyFilePath)`
Original file line number	Diff line number	Diff line change
`@@ -9,4 +9,6 @@ const (`
`9`	`9`
`10`	`10`	`DefaultL1RelayerBalance = "1000000"`
`11`	`11`	`DefaultL2RelayerBalance = "1000000"`
	`12`	`+ DefaultL1RelayerKeyName = "weave_l1_relayer"`
	`13`	`+ DefaultL2RelayerKeyName = "weave_l2_relayer"`
`12`	`14`	`)`