code.vegaprotocol.io/vega@v0.79.0/core/nodewallets/handler_test.go (about)

     1  // Copyright (C) 2023 Gobalsky Labs Limited
     2  //
     3  // This program is free software: you can redistribute it and/or modify
     4  // it under the terms of the GNU Affero General Public License as
     5  // published by the Free Software Foundation, either version 3 of the
     6  // License, or (at your option) any later version.
     7  //
     8  // This program is distributed in the hope that it will be useful,
     9  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    10  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    11  // GNU Affero General Public License for more details.
    12  //
    13  // You should have received a copy of the GNU Affero General Public License
    14  // along with this program.  If not, see <http://www.gnu.org/licenses/>.
    15  
    16  //go:build !race
    17  // +build !race
    18  
    19  package nodewallets_test
    20  
    21  import (
    22  	"testing"
    23  
    24  	"code.vegaprotocol.io/vega/core/nodewallets"
    25  	vgrand "code.vegaprotocol.io/vega/libs/rand"
    26  	vgtesting "code.vegaprotocol.io/vega/libs/testing"
    27  	"code.vegaprotocol.io/vega/paths"
    28  
    29  	"github.com/stretchr/testify/assert"
    30  	"github.com/stretchr/testify/require"
    31  )
    32  
    33  func TestHandler(t *testing.T) {
    34  	t.Run("Getting node wallets succeeds", testHandlerGettingNodeWalletsSucceeds)
    35  	t.Run("Getting node wallets with wrong registry passphrase fails", testHandlerGettingNodeWalletsWithWrongRegistryPassphraseFails)
    36  	t.Run("Getting Ethereum wallet succeeds", testHandlerGettingEthereumWalletSucceeds)
    37  	t.Run("Getting Ethereum wallet succeeds", testHandlerGettingEthereumWalletWithWrongRegistryPassphraseFails)
    38  	t.Run("Getting Vega wallet succeeds", testHandlerGettingVegaWalletSucceeds)
    39  	t.Run("Getting Vega wallet succeeds", testHandlerGettingVegaWalletWithWrongRegistryPassphraseFails)
    40  	t.Run("Generating Ethereum wallet succeeds", testHandlerGeneratingEthereumWalletSucceeds)
    41  	t.Run("Generating an already existing Ethereum wallet fails", testHandlerGeneratingAlreadyExistingEthereumWalletFails)
    42  	t.Run("Generating Ethereum wallet with overwrite succeeds", testHandlerGeneratingEthereumWalletWithOverwriteSucceeds)
    43  	t.Run("Generating Vega wallet succeeds", testHandlerGeneratingVegaWalletSucceeds)
    44  	t.Run("Generating an already existing Vega wallet fails", testHandlerGeneratingAlreadyExistingVegaWalletFails)
    45  	t.Run("Generating Vega wallet with overwrite succeeds", testHandlerGeneratingVegaWalletWithOverwriteSucceeds)
    46  	t.Run("Importing Ethereum wallet succeeds", testHandlerImportingEthereumWalletSucceeds)
    47  	t.Run("Importing an already existing Ethereum wallet fails", testHandlerImportingAlreadyExistingEthereumWalletFails)
    48  	t.Run("Importing Ethereum wallet with overwrite succeeds", testHandlerImportingEthereumWalletWithOverwriteSucceeds)
    49  	t.Run("Importing Vega wallet succeeds", testHandlerImportingVegaWalletSucceeds)
    50  	t.Run("Importing an already existing Vega wallet fails", testHandlerImportingAlreadyExistingVegaWalletFails)
    51  	t.Run("Importing Vega wallet with overwrite succeeds", testHandlerImportingVegaWalletWithOverwriteSucceeds)
    52  }
    53  
    54  func testHandlerGettingNodeWalletsSucceeds(t *testing.T) {
    55  	// given
    56  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
    57  	defer cleanupFn()
    58  	registryPass := vgrand.RandomStr(10)
    59  	walletsPass := vgrand.RandomStr(10)
    60  	config := nodewallets.NewDefaultConfig()
    61  
    62  	// setup
    63  	createTestNodeWallets(vegaPaths, registryPass, walletsPass)
    64  
    65  	// when
    66  	nw, err := nodewallets.GetNodeWallets(config, vegaPaths, registryPass)
    67  
    68  	// assert
    69  	require.NoError(t, err)
    70  	require.NotNil(t, nw)
    71  	require.NotNil(t, nw.Ethereum)
    72  	require.NotNil(t, nw.Vega)
    73  }
    74  
    75  func testHandlerGettingNodeWalletsWithWrongRegistryPassphraseFails(t *testing.T) {
    76  	// given
    77  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
    78  	defer cleanupFn()
    79  	registryPass := vgrand.RandomStr(10)
    80  	wrongRegistryPass := vgrand.RandomStr(10)
    81  	walletsPass := vgrand.RandomStr(10)
    82  	config := nodewallets.NewDefaultConfig()
    83  
    84  	// setup
    85  	createTestNodeWallets(vegaPaths, registryPass, walletsPass)
    86  
    87  	// when
    88  	nw, err := nodewallets.GetNodeWallets(config, vegaPaths, wrongRegistryPass)
    89  
    90  	// assert
    91  	require.Error(t, err)
    92  	assert.Nil(t, nw)
    93  }
    94  
    95  func testHandlerGettingEthereumWalletSucceeds(t *testing.T) {
    96  	// given
    97  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
    98  	defer cleanupFn()
    99  	registryPass := vgrand.RandomStr(10)
   100  	walletsPass := vgrand.RandomStr(10)
   101  
   102  	// setup
   103  	createTestNodeWallets(vegaPaths, registryPass, walletsPass)
   104  
   105  	// when
   106  	wallet, err := nodewallets.GetEthereumWallet(vegaPaths, registryPass)
   107  
   108  	// assert
   109  	require.NoError(t, err)
   110  	assert.NotNil(t, wallet)
   111  }
   112  
   113  func testHandlerGettingEthereumWalletWithWrongRegistryPassphraseFails(t *testing.T) {
   114  	// given
   115  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   116  	defer cleanupFn()
   117  	registryPass := vgrand.RandomStr(10)
   118  	wrongRegistryPass := vgrand.RandomStr(10)
   119  	walletsPass := vgrand.RandomStr(10)
   120  
   121  	// setup
   122  	createTestNodeWallets(vegaPaths, registryPass, walletsPass)
   123  
   124  	// when
   125  	wallet, err := nodewallets.GetEthereumWallet(vegaPaths, wrongRegistryPass)
   126  
   127  	// assert
   128  	require.Error(t, err)
   129  	assert.Nil(t, wallet)
   130  }
   131  
   132  func testHandlerGettingVegaWalletSucceeds(t *testing.T) {
   133  	// given
   134  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   135  	defer cleanupFn()
   136  	registryPass := vgrand.RandomStr(10)
   137  	walletsPass := vgrand.RandomStr(10)
   138  
   139  	// setup
   140  	createTestNodeWallets(vegaPaths, registryPass, walletsPass)
   141  
   142  	// when
   143  	wallet, err := nodewallets.GetVegaWallet(vegaPaths, registryPass)
   144  
   145  	// then
   146  	require.NoError(t, err)
   147  	assert.NotNil(t, wallet)
   148  }
   149  
   150  func testHandlerGettingVegaWalletWithWrongRegistryPassphraseFails(t *testing.T) {
   151  	// given
   152  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   153  	defer cleanupFn()
   154  	registryPass := vgrand.RandomStr(10)
   155  	wrongRegistryPass := vgrand.RandomStr(10)
   156  	walletsPass := vgrand.RandomStr(10)
   157  
   158  	// setup
   159  	createTestNodeWallets(vegaPaths, registryPass, walletsPass)
   160  
   161  	// when
   162  	wallet, err := nodewallets.GetVegaWallet(vegaPaths, wrongRegistryPass)
   163  
   164  	// assert
   165  	require.Error(t, err)
   166  	assert.Nil(t, wallet)
   167  }
   168  
   169  func testHandlerGeneratingEthereumWalletSucceeds(t *testing.T) {
   170  	// given
   171  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   172  	defer cleanupFn()
   173  	registryPass := vgrand.RandomStr(10)
   174  	walletPass := vgrand.RandomStr(10)
   175  
   176  	// when
   177  	data, err := nodewallets.GenerateEthereumWallet(vegaPaths, registryPass, walletPass, "", false)
   178  
   179  	// then
   180  	require.NoError(t, err)
   181  	assert.NotEmpty(t, data["registryFilePath"])
   182  	assert.NotEmpty(t, data["walletFilePath"])
   183  }
   184  
   185  func testHandlerGeneratingAlreadyExistingEthereumWalletFails(t *testing.T) {
   186  	// given
   187  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   188  	defer cleanupFn()
   189  	registryPass := vgrand.RandomStr(10)
   190  	walletPass1 := vgrand.RandomStr(10)
   191  
   192  	// when
   193  	data1, err := nodewallets.GenerateEthereumWallet(vegaPaths, registryPass, walletPass1, "", false)
   194  
   195  	// then
   196  	require.NoError(t, err)
   197  	assert.NotEmpty(t, data1["registryFilePath"])
   198  	assert.NotEmpty(t, data1["walletFilePath"])
   199  
   200  	// given
   201  	walletPass2 := vgrand.RandomStr(10)
   202  
   203  	// when
   204  	data2, err := nodewallets.GenerateEthereumWallet(vegaPaths, registryPass, walletPass2, "", false)
   205  
   206  	// then
   207  	require.EqualError(t, err, nodewallets.ErrEthereumWalletAlreadyExists.Error())
   208  	assert.Empty(t, data2)
   209  }
   210  
   211  func testHandlerGeneratingEthereumWalletWithOverwriteSucceeds(t *testing.T) {
   212  	// given
   213  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   214  	defer cleanupFn()
   215  	registryPass := vgrand.RandomStr(10)
   216  	walletPass1 := vgrand.RandomStr(10)
   217  
   218  	// when
   219  	data1, err := nodewallets.GenerateEthereumWallet(vegaPaths, registryPass, walletPass1, "", false)
   220  
   221  	// then
   222  	require.NoError(t, err)
   223  	assert.NotEmpty(t, data1["registryFilePath"])
   224  	assert.NotEmpty(t, data1["walletFilePath"])
   225  
   226  	// given
   227  	walletPass2 := vgrand.RandomStr(10)
   228  
   229  	// when
   230  	data2, err := nodewallets.GenerateEthereumWallet(vegaPaths, registryPass, walletPass2, "", true)
   231  
   232  	// then
   233  	require.NoError(t, err)
   234  	assert.NotEmpty(t, data2["registryFilePath"])
   235  	assert.Equal(t, data1["registryFilePath"], data2["registryFilePath"])
   236  	assert.NotEmpty(t, data2["walletFilePath"])
   237  	assert.NotEqual(t, data1["walletFilePath"], data2["walletFilePath"])
   238  }
   239  
   240  func testHandlerGeneratingVegaWalletSucceeds(t *testing.T) {
   241  	// given
   242  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   243  	defer cleanupFn()
   244  	registryPass := vgrand.RandomStr(10)
   245  	walletPass := vgrand.RandomStr(10)
   246  
   247  	// when
   248  	data, err := nodewallets.GenerateVegaWallet(vegaPaths, registryPass, walletPass, false)
   249  
   250  	// then
   251  	require.NoError(t, err)
   252  	assert.NotEmpty(t, data["registryFilePath"])
   253  	assert.NotEmpty(t, data["walletFilePath"])
   254  	assert.NotEmpty(t, data["mnemonic"])
   255  }
   256  
   257  func testHandlerGeneratingAlreadyExistingVegaWalletFails(t *testing.T) {
   258  	// given
   259  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   260  	defer cleanupFn()
   261  	registryPass := vgrand.RandomStr(10)
   262  	walletPass1 := vgrand.RandomStr(10)
   263  
   264  	// when
   265  	data1, err := nodewallets.GenerateVegaWallet(vegaPaths, registryPass, walletPass1, false)
   266  
   267  	// then
   268  	require.NoError(t, err)
   269  	assert.NotEmpty(t, data1["registryFilePath"])
   270  	assert.NotEmpty(t, data1["walletFilePath"])
   271  	assert.NotEmpty(t, data1["mnemonic"])
   272  
   273  	// given
   274  	walletPass2 := vgrand.RandomStr(10)
   275  
   276  	// when
   277  	data2, err := nodewallets.GenerateVegaWallet(vegaPaths, registryPass, walletPass2, false)
   278  
   279  	// then
   280  	require.EqualError(t, err, nodewallets.ErrVegaWalletAlreadyExists.Error())
   281  	assert.Empty(t, data2)
   282  }
   283  
   284  func testHandlerGeneratingVegaWalletWithOverwriteSucceeds(t *testing.T) {
   285  	// given
   286  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   287  	defer cleanupFn()
   288  	registryPass := vgrand.RandomStr(10)
   289  	walletPass1 := vgrand.RandomStr(10)
   290  
   291  	// when
   292  	data1, err := nodewallets.GenerateVegaWallet(vegaPaths, registryPass, walletPass1, false)
   293  
   294  	// then
   295  	require.NoError(t, err)
   296  	assert.NotEmpty(t, data1["registryFilePath"])
   297  	assert.NotEmpty(t, data1["walletFilePath"])
   298  
   299  	// given
   300  	walletPass2 := vgrand.RandomStr(10)
   301  
   302  	// when
   303  	data2, err := nodewallets.GenerateVegaWallet(vegaPaths, registryPass, walletPass2, true)
   304  
   305  	// then
   306  	require.NoError(t, err)
   307  	assert.NotEmpty(t, data2["registryFilePath"])
   308  	assert.Equal(t, data1["registryFilePath"], data2["registryFilePath"])
   309  	assert.NotEmpty(t, data2["walletFilePath"])
   310  	assert.NotEqual(t, data1["walletFilePath"], data2["walletFilePath"])
   311  	assert.NotEmpty(t, data2["mnemonic"])
   312  	assert.NotEqual(t, data1["mnemonic"], data2["mnemonic"])
   313  }
   314  
   315  func testHandlerImportingEthereumWalletSucceeds(t *testing.T) {
   316  	// given
   317  	genVegaPaths, genCleanupFn := vgtesting.NewVegaPaths()
   318  	defer genCleanupFn()
   319  	registryPass := vgrand.RandomStr(10)
   320  	walletPass := vgrand.RandomStr(10)
   321  
   322  	// when
   323  	genData, err := nodewallets.GenerateEthereumWallet(genVegaPaths, registryPass, walletPass, "", false)
   324  
   325  	// then
   326  	require.NoError(t, err)
   327  
   328  	// given
   329  	importVegaPaths, importCleanupFn := vgtesting.NewVegaPaths()
   330  	defer importCleanupFn()
   331  
   332  	// when
   333  	importData, err := nodewallets.ImportEthereumWallet(importVegaPaths, registryPass, walletPass, "", "", genData["walletFilePath"], false)
   334  
   335  	// then
   336  	require.NoError(t, err)
   337  	assert.NotEmpty(t, importData["registryFilePath"])
   338  	assert.NotEqual(t, genData["registryFilePath"], importData["registryFilePath"])
   339  	assert.NotEmpty(t, importData["walletFilePath"])
   340  	assert.NotEqual(t, genData["walletFilePath"], importData["walletFilePath"])
   341  }
   342  
   343  func testHandlerImportingAlreadyExistingEthereumWalletFails(t *testing.T) {
   344  	// given
   345  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   346  	defer cleanupFn()
   347  	registryPass := vgrand.RandomStr(10)
   348  	walletPass := vgrand.RandomStr(10)
   349  
   350  	// when
   351  	genData, err := nodewallets.GenerateEthereumWallet(vegaPaths, registryPass, walletPass, "", false)
   352  
   353  	// then
   354  	require.NoError(t, err)
   355  
   356  	// when
   357  	importData, err := nodewallets.ImportEthereumWallet(vegaPaths, registryPass, walletPass, "", genData["walletFilePath"], "", false)
   358  
   359  	// then
   360  	require.EqualError(t, err, nodewallets.ErrEthereumWalletAlreadyExists.Error())
   361  	assert.Empty(t, importData)
   362  }
   363  
   364  func testHandlerImportingEthereumWalletWithOverwriteSucceeds(t *testing.T) {
   365  	// given
   366  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   367  	defer cleanupFn()
   368  	registryPass := vgrand.RandomStr(10)
   369  	walletPass := vgrand.RandomStr(10)
   370  
   371  	// when
   372  	genData, err := nodewallets.GenerateEthereumWallet(vegaPaths, registryPass, walletPass, "", false)
   373  
   374  	// then
   375  	require.NoError(t, err)
   376  
   377  	// when
   378  	importData, err := nodewallets.ImportEthereumWallet(vegaPaths, registryPass, walletPass, "", "", genData["walletFilePath"], true)
   379  
   380  	// then
   381  	require.NoError(t, err)
   382  	assert.NotEmpty(t, genData["registryFilePath"])
   383  	assert.Equal(t, importData["registryFilePath"], genData["registryFilePath"])
   384  	assert.NotEmpty(t, genData["walletFilePath"])
   385  	assert.Equal(t, importData["walletFilePath"], genData["walletFilePath"])
   386  }
   387  
   388  func testHandlerImportingVegaWalletSucceeds(t *testing.T) {
   389  	// given
   390  	genVegaPaths, genCleanupFn := vgtesting.NewVegaPaths()
   391  	defer genCleanupFn()
   392  	registryPass := vgrand.RandomStr(10)
   393  	walletPass := vgrand.RandomStr(10)
   394  
   395  	// when
   396  	genData, err := nodewallets.GenerateVegaWallet(genVegaPaths, registryPass, walletPass, false)
   397  
   398  	// then
   399  	require.NoError(t, err)
   400  
   401  	// given
   402  	importVegaPaths, importCleanupFn := vgtesting.NewVegaPaths()
   403  	defer importCleanupFn()
   404  
   405  	// when
   406  	importData, err := nodewallets.ImportVegaWallet(importVegaPaths, registryPass, walletPass, genData["walletFilePath"], false)
   407  
   408  	// then
   409  	require.NoError(t, err)
   410  	assert.NotEmpty(t, importData["registryFilePath"])
   411  	assert.NotEqual(t, genData["registryFilePath"], importData["registryFilePath"])
   412  	assert.NotEmpty(t, importData["walletFilePath"])
   413  	assert.NotEqual(t, genData["walletFilePath"], importData["walletFilePath"])
   414  }
   415  
   416  func testHandlerImportingAlreadyExistingVegaWalletFails(t *testing.T) {
   417  	// given
   418  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   419  	defer cleanupFn()
   420  	registryPass := vgrand.RandomStr(10)
   421  	walletPass := vgrand.RandomStr(10)
   422  
   423  	// when
   424  	genData, err := nodewallets.GenerateVegaWallet(vegaPaths, registryPass, walletPass, false)
   425  
   426  	// then
   427  	require.NoError(t, err)
   428  
   429  	// when
   430  	importData, err := nodewallets.ImportVegaWallet(vegaPaths, registryPass, walletPass, genData["walletFilePath"], false)
   431  
   432  	// then
   433  	require.EqualError(t, err, nodewallets.ErrVegaWalletAlreadyExists.Error())
   434  	assert.Empty(t, importData)
   435  }
   436  
   437  func testHandlerImportingVegaWalletWithOverwriteSucceeds(t *testing.T) {
   438  	// given
   439  	vegaPaths, cleanupFn := vgtesting.NewVegaPaths()
   440  	defer cleanupFn()
   441  	registryPass := vgrand.RandomStr(10)
   442  	walletPass := vgrand.RandomStr(10)
   443  
   444  	// when
   445  	genData, err := nodewallets.GenerateVegaWallet(vegaPaths, registryPass, walletPass, false)
   446  
   447  	// then
   448  	require.NoError(t, err)
   449  
   450  	// when
   451  	importData, err := nodewallets.ImportVegaWallet(vegaPaths, registryPass, walletPass, genData["walletFilePath"], true)
   452  
   453  	// then
   454  	require.NoError(t, err)
   455  	assert.NotEmpty(t, importData["registryFilePath"])
   456  	assert.Equal(t, genData["registryFilePath"], importData["registryFilePath"])
   457  	assert.NotEmpty(t, importData["walletFilePath"])
   458  	assert.NotEqual(t, genData["walletFilePath"], importData["walletFilePath"])
   459  }
   460  
   461  func createTestNodeWallets(vegaPaths paths.Paths, registryPass, walletPass string) {
   462  	if _, err := nodewallets.GenerateEthereumWallet(vegaPaths, registryPass, walletPass, "", false); err != nil {
   463  		panic("couldn't generate Ethereum node wallet for tests")
   464  	}
   465  
   466  	if _, err := nodewallets.GenerateVegaWallet(vegaPaths, registryPass, walletPass, false); err != nil {
   467  		panic("couldn't generate Vega node wallet for tests")
   468  	}
   469  }