feat(grpc): add RestoreWallet API

wallet/manager.go

@@ -38,7 +38,7 @@ func (w *Manager) walletExists(walletName string) bool {
 }
 
 func (w *Manager) createWalletWithMnemonic(
-	mnemonic, password, walletName string,
+	walletName, mnemonic, password string,
 ) error {
 	walletPath := util.MakeAbs(filepath.Join(w.walletDirectory, walletName))
 	wlt, err := Create(walletPath, mnemonic, password, w.chainType)
@@ -76,16 +76,22 @@ func (w *Manager) CreateWallet(
 		return "", status.Errorf(codes.AlreadyExists, "wallet already exists")
 	}
 
-	if err := w.createWalletWithMnemonic(mnemonic, password, walletName); err != nil {
+	if err := w.createWalletWithMnemonic(walletName, mnemonic, password); err != nil {
 		return "", err
 	}
 
 	return mnemonic, nil
 }
 
-func (w *Manager) LoadWallet(
-	walletName, walletPath string,
-) error {
+func (w *Manager) RestoreWallet(walletName, mnemonic, password string) error {
+	if isExists := w.walletExists(walletName); isExists {
+		return status.Errorf(codes.AlreadyExists, "wallet already exists")
+	}
+
+	return w.createWalletWithMnemonic(walletName, mnemonic, password)
+}
+
+func (w *Manager) LoadWallet(walletName string) error {
 	if _, ok := w.wallets[walletName]; ok {
 		// TODO: define special codes for errors
 		return status.Errorf(codes.AlreadyExists, "wallet already loaded")

www/grpc/buf/grpc-gateway.config.yaml

@@ -67,6 +67,9 @@ http:
     - selector: pactus.Wallet.CreateWallet
       get: "/pactus/wallet/create_wallet"
 
+    - selector: pactus.Wallet.RestoreWallet
+      get: "/pactus/wallet/restore_wallet"
+
     - selector: pactus.Wallet.LoadWallet
       get: "/pactus/wallet/load_wallet"
 

www/grpc/wallet.go

@@ -73,6 +73,27 @@ func (s *walletServer) CreateWallet(_ context.Context,
 	}, nil
 }
 
+func (s *walletServer) RestoreWallet(_ context.Context,
+	req *pactus.RestoreWalletRequest,
+) (*pactus.RestoreWalletResponse, error) {
+	if req.WalletName == "" {
+		return nil, fmt.Errorf("wallet name is required")
+	}
+	if req.Mnemonic == "" {
+		return nil, fmt.Errorf("mnemonic is required")
+	}
+
+	if err := s.walletManager.RestoreWallet(
+		req.WalletName, req.Mnemonic, req.Password,
+	); err != nil {
+		return nil, err
+	}
+
+	return &pactus.RestoreWalletResponse{
+		WalletName: req.WalletName,
+	}, nil
+}
+
 func (s *walletServer) LoadWallet(_ context.Context,
 	req *pactus.LoadWalletRequest,
 ) (*pactus.LoadWalletResponse, error) {

www/grpc/wallet_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/pactus-project/pactus/crypto"
 	"github.com/pactus-project/pactus/types/tx"
+	"github.com/pactus-project/pactus/wallet"
 	pactus "github.com/pactus-project/pactus/www/grpc/gen/go"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -31,6 +32,46 @@ func TestDisableWallet(t *testing.T) {
 	td.StopServer()
 }
 
+func TestRestoreWallet(t *testing.T) {
+	config := testConfig()
+	config.EnableWallet = true
+
+	td := setup(t, config)
+	conn, client := td.walletClient(t)
+
+	t.Run("should return error if no wallet name provided", func(t *testing.T) {
+		res, err := client.RestoreWallet(context.Background(),
+			&pactus.RestoreWalletRequest{})
+		assert.Error(t, err)
+		assert.Nil(t, res)
+	})
+
+	t.Run("should return error if no mnemonic provided", func(t *testing.T) {
+		res, err := client.RestoreWallet(context.Background(),
+			&pactus.RestoreWalletRequest{
+				WalletName: "test",
+			})
+		assert.Error(t, err)
+		assert.Nil(t, res)
+	})
+
+	t.Run("should restore wallet", func(t *testing.T) {
+		mnemonic, err := wallet.GenerateMnemonic(128)
+		assert.NoError(t, err)
+
+		res, err := client.RestoreWallet(context.Background(),
+			&pactus.RestoreWalletRequest{
+				WalletName: "test",
+				Mnemonic:   mnemonic,
+			})
+		assert.NoError(t, err)
+		assert.NotNil(t, res)
+	})
+
+	assert.Nil(t, conn.Close(), "Error closing connection")
+	td.StopServer()
+}
+
 func TestCreateWallet(t *testing.T) {
 	conf := testConfig()
 	conf.EnableWallet = true