From dd894ece15c1dbcbb741fc99d7dca33c951a6223 Mon Sep 17 00:00:00 2001 From: Pedro Pombeiro Date: Wed, 11 Dec 2019 14:59:37 +0100 Subject: [PATCH] Start abstracting geth Keystore --- account/accounts.go | 36 ++++++------- account/accounts_test.go | 32 +++++------ account/generator/generator.go | 6 +-- account/utils.go | 35 ++++++++---- account/utils_test.go | 23 ++++++-- api/backend_subs_test.go | 6 +-- api/backend_test.go | 32 +++++------ api/geth_backend.go | 10 ++-- lib/library_test_utils.go | 21 ++++---- multiaccounts/accounts/database.go | 21 ++++---- multiaccounts/accounts/database_test.go | 43 ++++++++------- services/accounts/accounts.go | 4 +- services/status/api.go | 7 +-- services/status/api_test.go | 10 ++-- services/wallet/service.go | 4 +- services/wallet/service_test.go | 12 +++-- t/devtests/devnode.go | 6 +-- t/devtests/tranfers_test.go | 9 ++-- t/e2e/accounts/accounts_test.go | 18 +++---- t/e2e/transactions/transactions_test.go | 37 +++++++------ t/e2e/whisper/whisper_test.go | 17 +++--- transactions/transactor_test.go | 72 ++++++++++++------------- 22 files changed, 245 insertions(+), 216 deletions(-) diff --git a/account/accounts.go b/account/accounts.go index 49f900cd5..ddefbe28d 100644 --- a/account/accounts.go +++ b/account/accounts.go @@ -13,10 +13,10 @@ import ( "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/accounts/keystore" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" "github.com/pborman/uuid" "github.com/status-im/status-go/account/generator" + "github.com/status-im/status-go/eth-node/crypto" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/extkeys" ) @@ -32,7 +32,7 @@ var ( ErrAccountKeyStoreMissing = errors.New("account key store is not set") ) -var zeroAddress = common.Address{} +var zeroAddress = types.Address{} // Manager represents account manager interface. type Manager struct { @@ -44,8 +44,8 @@ type Manager struct { onboarding *Onboarding selectedChatAccount *SelectedExtKey // account that was processed during the last call to SelectAccount() - mainAccountAddress common.Address - watchAddresses []common.Address + mainAccountAddress types.Address + watchAddresses []types.Address } // NewManager returns new node account manager. @@ -157,7 +157,7 @@ func (m *Manager) VerifyAccountPassword(keyStoreDir, address, password string) ( var err error var foundKeyFile []byte - addressObj := common.BytesToAddress(common.FromHex(address)) + addressObj := types.BytesToAddress(types.FromHex(address)) checkAccountKey := func(path string, fileInfo os.FileInfo) error { if len(foundKeyFile) > 0 || fileInfo.IsDir() { return nil @@ -175,7 +175,7 @@ func (m *Manager) VerifyAccountPassword(keyStoreDir, address, password string) ( return fmt.Errorf("failed to read key file: %s", e) } - if common.HexToAddress("0x"+accountKey.Address).Hex() == addressObj.Hex() { + if types.HexToAddress("0x"+accountKey.Address).Hex() == addressObj.Hex() { foundKeyFile = rawKeyFile } @@ -202,7 +202,7 @@ func (m *Manager) VerifyAccountPassword(keyStoreDir, address, password string) ( } // avoid swap attack - if key.Address != addressObj { + if types.Address(key.Address) != addressObj { return nil, fmt.Errorf("account mismatch: have %s, want %s", key.Address.Hex(), addressObj.Hex()) } @@ -227,8 +227,8 @@ func (m *Manager) SelectAccount(loginParams LoginParams) error { return nil } -func (m *Manager) SetAccountAddresses(main common.Address, secondary ...common.Address) { - m.watchAddresses = []common.Address{main} +func (m *Manager) SetAccountAddresses(main types.Address, secondary ...types.Address) { + m.watchAddresses = []types.Address{main} m.watchAddresses = append(m.watchAddresses, secondary...) m.mainAccountAddress = main } @@ -242,7 +242,7 @@ func (m *Manager) SetChatAccount(privKey *ecdsa.PrivateKey) { id := uuid.NewRandom() key := &keystore.Key{ Id: id, - Address: address, + Address: common.Address(address), PrivateKey: privKey, } @@ -253,7 +253,7 @@ func (m *Manager) SetChatAccount(privKey *ecdsa.PrivateKey) { } // MainAccountAddress returns currently selected watch addresses. -func (m *Manager) MainAccountAddress() (common.Address, error) { +func (m *Manager) MainAccountAddress() (types.Address, error) { m.mu.RLock() defer m.mu.RUnlock() @@ -265,7 +265,7 @@ func (m *Manager) MainAccountAddress() (common.Address, error) { } // WatchAddresses returns currently selected watch addresses. -func (m *Manager) WatchAddresses() []common.Address { +func (m *Manager) WatchAddresses() []types.Address { m.mu.RLock() defer m.mu.RUnlock() @@ -295,14 +295,14 @@ func (m *Manager) Logout() { } // ImportAccount imports the account specified with privateKey. -func (m *Manager) ImportAccount(privateKey *ecdsa.PrivateKey, password string) (common.Address, error) { +func (m *Manager) ImportAccount(privateKey *ecdsa.PrivateKey, password string) (types.Address, error) { if m.keystore == nil { - return common.Address{}, ErrAccountKeyStoreMissing + return types.Address{}, ErrAccountKeyStoreMissing } account, err := m.keystore.ImportECDSA(privateKey, password) - return account.Address, err + return types.Address(account.Address), err } func (m *Manager) ImportSingleExtendedKey(extKey *extkeys.ExtendedKey, password string) (address, pubKey string, err error) { @@ -355,10 +355,10 @@ func (m *Manager) importExtendedKey(keyPurpose extkeys.KeyPurpose, extKey *extke // Accounts returns list of addresses for selected account, including // subaccounts. -func (m *Manager) Accounts() ([]common.Address, error) { +func (m *Manager) Accounts() ([]types.Address, error) { m.mu.RLock() defer m.mu.RUnlock() - addresses := make([]common.Address, 0) + addresses := make([]types.Address, 0) if m.mainAccountAddress != zeroAddress { addresses = append(addresses, m.mainAccountAddress) } @@ -444,7 +444,7 @@ func (m *Manager) unlockExtendedKey(address, password string) (*SelectedExtKey, } selectedExtendedKey := &SelectedExtKey{ - Address: account.Address, + Address: types.Address(account.Address), AccountKey: accountKey, } diff --git a/account/accounts_test.go b/account/accounts_test.go index bd2a3a13a..b65c6698b 100644 --- a/account/accounts_test.go +++ b/account/accounts_test.go @@ -9,10 +9,10 @@ import ( "reflect" "testing" + "github.com/status-im/status-go/eth-node/crypto" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/t/utils" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" ) @@ -32,7 +32,7 @@ func TestVerifyAccountPassword(t *testing.T) { require.NoError(t, utils.ImportTestAccount(keyStoreDir, utils.GetAccount1PKFile())) require.NoError(t, utils.ImportTestAccount(keyStoreDir, utils.GetAccount2PKFile())) - account1Address := common.BytesToAddress(common.FromHex(utils.TestConfig.Account1.WalletAddress)) + account1Address := types.BytesToAddress(types.FromHex(utils.TestConfig.Account1.WalletAddress)) testCases := []struct { name string @@ -86,8 +86,8 @@ func TestVerifyAccountPassword(t *testing.T) { if accountKey == nil { require.Fail(t, "no error reported, but account key is missing") } - accountAddress := common.BytesToAddress(common.FromHex(testCase.address)) - if accountKey.Address != accountAddress { + accountAddress := types.BytesToAddress(types.FromHex(testCase.address)) + if types.Address(accountKey.Address) != accountAddress { require.Fail(t, "account mismatch: have %s, want %s", accountKey.Address.Hex(), accountAddress.Hex()) } } @@ -108,7 +108,7 @@ func TestVerifyAccountPasswordWithAccountBeforeEIP55(t *testing.T) { accManager := NewManager() - address := common.HexToAddress(utils.TestConfig.Account3.WalletAddress) + address := types.HexToAddress(utils.TestConfig.Account3.WalletAddress) _, err = accManager.VerifyAccountPassword(keyStoreDir, address.Hex(), utils.TestConfig.Account3.Password) require.NoError(t, err) } @@ -220,18 +220,18 @@ func (s *ManagerTestSuite) TestOnboarding() { } func (s *ManagerTestSuite) TestSelectAccountSuccess() { - s.testSelectAccount(common.HexToAddress(s.testAccount.chatAddress), common.HexToAddress(s.testAccount.walletAddress), s.testAccount.password, nil) + s.testSelectAccount(types.HexToAddress(s.testAccount.chatAddress), types.HexToAddress(s.testAccount.walletAddress), s.testAccount.password, nil) } func (s *ManagerTestSuite) TestSelectAccountWrongAddress() { - s.testSelectAccount(common.HexToAddress("0x0000000000000000000000000000000000000001"), common.HexToAddress(s.testAccount.walletAddress), s.testAccount.password, errors.New("cannot retrieve a valid key for a given account: no key for given address or file")) + s.testSelectAccount(types.HexToAddress("0x0000000000000000000000000000000000000001"), types.HexToAddress(s.testAccount.walletAddress), s.testAccount.password, errors.New("cannot retrieve a valid key for a given account: no key for given address or file")) } func (s *ManagerTestSuite) TestSelectAccountWrongPassword() { - s.testSelectAccount(common.HexToAddress(s.testAccount.chatAddress), common.HexToAddress(s.testAccount.walletAddress), "wrong", errors.New("cannot retrieve a valid key for a given account: could not decrypt key with given password")) + s.testSelectAccount(types.HexToAddress(s.testAccount.chatAddress), types.HexToAddress(s.testAccount.walletAddress), "wrong", errors.New("cannot retrieve a valid key for a given account: could not decrypt key with given password")) } -func (s *ManagerTestSuite) testSelectAccount(chat, wallet common.Address, password string, expErr error) { +func (s *ManagerTestSuite) testSelectAccount(chat, wallet types.Address, password string, expErr error) { loginParams := LoginParams{ ChatAddress: chat, MainAccount: wallet, @@ -249,7 +249,7 @@ func (s *ManagerTestSuite) testSelectAccount(chat, wallet common.Address, passwo s.Equal(wallet, selectedMainAccountAddress) s.Equal(chat, crypto.PubkeyToAddress(selectedChatAccount.AccountKey.PrivateKey.PublicKey)) } else { - s.Equal(common.Address{}, selectedMainAccountAddress) + s.Equal(types.Address{}, selectedMainAccountAddress) s.Nil(selectedChatAccount) s.Equal(walletErr, ErrNoAccountSelected) s.Equal(chatErr, ErrNoAccountSelected) @@ -275,12 +275,12 @@ func (s *ManagerTestSuite) TestSetChatAccount() { selectedMainAccountAddress, err := s.accManager.MainAccountAddress() s.Error(err) - s.Equal(common.Address{}, selectedMainAccountAddress) + s.Equal(types.Address{}, selectedMainAccountAddress) } func (s *ManagerTestSuite) TestLogout() { s.accManager.Logout() - s.Equal(common.Address{}, s.accManager.mainAccountAddress) + s.Equal(types.Address{}, s.accManager.mainAccountAddress) s.Nil(s.accManager.selectedChatAccount) s.Len(s.accManager.watchAddresses, 0) } @@ -289,8 +289,8 @@ func (s *ManagerTestSuite) TestLogout() { func (s *ManagerTestSuite) TestAccounts() { // Select the test account loginParams := LoginParams{ - MainAccount: common.HexToAddress(s.walletAddress), - ChatAddress: common.HexToAddress(s.chatAddress), + MainAccount: types.HexToAddress(s.walletAddress), + ChatAddress: types.HexToAddress(s.chatAddress), Password: s.password, } err := s.accManager.SelectAccount(loginParams) @@ -301,7 +301,7 @@ func (s *ManagerTestSuite) TestAccounts() { s.NoError(err) s.NotNil(accs) // Selected main account address is zero address but doesn't fail - s.accManager.mainAccountAddress = common.Address{} + s.accManager.mainAccountAddress = types.Address{} accs, err = s.accManager.Accounts() s.NoError(err) s.NotNil(accs) diff --git a/account/generator/generator.go b/account/generator/generator.go index a3e2e488a..1ac234ea1 100644 --- a/account/generator/generator.go +++ b/account/generator/generator.go @@ -9,9 +9,9 @@ import ( "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/accounts/keystore" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" "github.com/pborman/uuid" + "github.com/status-im/status-go/eth-node/crypto" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/extkeys" ) @@ -27,7 +27,7 @@ var ( type AccountManager interface { AddressToDecryptedAccount(address, password string) (accounts.Account, *keystore.Key, error) ImportSingleExtendedKey(extKey *extkeys.ExtendedKey, password string) (address, pubKey string, err error) - ImportAccount(privateKey *ecdsa.PrivateKey, password string) (common.Address, error) + ImportAccount(privateKey *ecdsa.PrivateKey, password string) (types.Address, error) } type Generator struct { diff --git a/account/utils.go b/account/utils.go index 703ed64c6..bdd6e5e84 100644 --- a/account/utils.go +++ b/account/utils.go @@ -8,6 +8,8 @@ import ( "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/accounts/keystore" "github.com/ethereum/go-ethereum/common" + + "github.com/status-im/status-go/eth-node/types" ) // errors @@ -17,10 +19,10 @@ var ( ) type LoginParams struct { - ChatAddress common.Address `json:"chatAddress"` - Password string `json:"password"` - MainAccount common.Address `json:"mainAccount"` - WatchAddresses []common.Address `json:"watchAddresses"` + ChatAddress types.Address `json:"chatAddress"` + Password string `json:"password"` + MainAccount types.Address `json:"mainAccount"` + WatchAddresses []types.Address `json:"watchAddresses"` } type ErrZeroAddress struct { @@ -40,7 +42,7 @@ func newErrZeroAddress(field string) *ErrZeroAddress { func ParseLoginParams(paramsJSON string) (LoginParams, error) { var ( params LoginParams - zeroAddress common.Address + zeroAddress types.Address ) if err := json.Unmarshal([]byte(paramsJSON), ¶ms); err != nil { return params, err @@ -72,7 +74,7 @@ type Info struct { // SelectedExtKey is a container for the selected (logged in) external account. type SelectedExtKey struct { - Address common.Address + Address types.Address AccountKey *keystore.Key SubAccounts []accounts.Account } @@ -89,16 +91,16 @@ func (k *SelectedExtKey) Hex() string { // ParseAccountString parses hex encoded string and returns is as accounts.Account. func ParseAccountString(account string) (accounts.Account, error) { // valid address, convert to account - if common.IsHexAddress(account) { + if types.IsHexAddress(account) { return accounts.Account{Address: common.HexToAddress(account)}, nil } return accounts.Account{}, ErrInvalidAccountAddressOrKey } -// FromAddress converts account address from string to common.Address. +// GethFromAddress converts account address from string to common.Address. // The function is useful to format "From" field of send transaction struct. -func FromAddress(accountAddress string) common.Address { +func GethFromAddress(accountAddress string) common.Address { from, err := ParseAccountString(accountAddress) if err != nil { return common.Address{} @@ -107,9 +109,20 @@ func FromAddress(accountAddress string) common.Address { return from.Address } -// ToAddress converts account address from string to *common.Address. +// FromAddress converts account address from string to types.Address. +// The function is useful to format "From" field of send transaction struct. +func FromAddress(accountAddress string) types.Address { + from, err := ParseAccountString(accountAddress) + if err != nil { + return types.Address{} + } + + return types.Address(from.Address) +} + +// GethToAddress converts account address from string to *common.Address. // The function is useful to format "To" field of send transaction struct. -func ToAddress(accountAddress string) *common.Address { +func GethToAddress(accountAddress string) *common.Address { to, err := ParseAccountString(accountAddress) if err != nil { return nil diff --git a/account/utils_test.go b/account/utils_test.go index 55e839155..b33032928 100644 --- a/account/utils_test.go +++ b/account/utils_test.go @@ -21,13 +21,13 @@ func (suite *AccountUtilsTestSuite) SetupTest() { suite.validKey = "0xF35E0325dad87e2661c4eF951d58727e6d583d5c" } -func (suite *AccountUtilsTestSuite) TestToAddress() { - addr := ToAddress(suite.validKey) +func (suite *AccountUtilsTestSuite) TestGethToAddress() { + addr := GethToAddress(suite.validKey) suite.Equal(suite.validKey, addr.String()) } -func (suite *AccountUtilsTestSuite) TestToAddressInvalidAddress() { - addr := ToAddress("foobar") +func (suite *AccountUtilsTestSuite) TestGethToAddressInvalidAddress() { + addr := GethToAddress("foobar") suite.Nil(addr) } @@ -46,6 +46,21 @@ func (suite *AccountUtilsTestSuite) TestFromAddress() { } } +func (suite *AccountUtilsTestSuite) TestGethFromAddress() { + var flagtests = []struct { + in string + out string + }{ + {suite.validKey, suite.validKey}, + {"foobar", "0x0000000000000000000000000000000000000000"}, + } + + for _, tt := range flagtests { + addr := GethFromAddress(tt.in) + suite.Equal(tt.out, addr.String()) + } +} + func (suite *AccountUtilsTestSuite) TestHex() { var addr *SelectedExtKey cr, _ := crypto.GenerateKey() diff --git a/api/backend_subs_test.go b/api/backend_subs_test.go index e1c59fa67..54763b478 100644 --- a/api/backend_subs_test.go +++ b/api/backend_subs_test.go @@ -6,8 +6,8 @@ import ( "testing" "time" - "github.com/ethereum/go-ethereum/common" "github.com/status-im/status-go/account" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/node" "github.com/status-im/status-go/params" "github.com/status-im/status-go/signal" @@ -245,8 +245,8 @@ func initNodeAndLogin(t *testing.T, backend *GethStatusBackend) (string, string) require.NoError(t, err) loginParams := account.LoginParams{ - MainAccount: common.HexToAddress(info.WalletAddress), - ChatAddress: common.HexToAddress(info.ChatAddress), + MainAccount: types.HexToAddress(info.WalletAddress), + ChatAddress: types.HexToAddress(info.ChatAddress), Password: password, } require.NoError(t, backend.AccountManager().SelectAccount(loginParams)) diff --git a/api/backend_test.go b/api/backend_test.go index bafd52dc8..bb5214ed3 100644 --- a/api/backend_test.go +++ b/api/backend_test.go @@ -12,9 +12,9 @@ import ( "sync" "testing" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" + gethcrypto "github.com/ethereum/go-ethereum/crypto" "github.com/status-im/status-go/account" + "github.com/status-im/status-go/eth-node/crypto" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/multiaccounts" "github.com/status-im/status-go/multiaccounts/accounts" @@ -183,8 +183,8 @@ func TestBackendAccountsConcurrently(t *testing.T) { wg.Add(1) go func(tuple [3]string) { loginParams := account.LoginParams{ - MainAccount: common.HexToAddress(tuple[0]), - ChatAddress: common.HexToAddress(tuple[1]), + MainAccount: types.HexToAddress(tuple[0]), + ChatAddress: types.HexToAddress(tuple[1]), Password: tuple[2], } assert.NoError(t, backend.SelectAccount(loginParams)) @@ -220,14 +220,14 @@ func TestBackendInjectChatAccount(t *testing.T) { require.NoError(t, backend.StopNode()) }() - chatPrivKey, err := crypto.GenerateKey() + chatPrivKey, err := gethcrypto.GenerateKey() require.NoError(t, err) - encryptionPrivKey, err := crypto.GenerateKey() + encryptionPrivKey, err := gethcrypto.GenerateKey() require.NoError(t, err) - chatPrivKeyHex := hex.EncodeToString(crypto.FromECDSA(chatPrivKey)) - chatPubKeyHex := types.EncodeHex(crypto.FromECDSAPub(&chatPrivKey.PublicKey)) - encryptionPrivKeyHex := hex.EncodeToString(crypto.FromECDSA(encryptionPrivKey)) + chatPrivKeyHex := hex.EncodeToString(gethcrypto.FromECDSA(chatPrivKey)) + chatPubKeyHex := types.EncodeHex(gethcrypto.FromECDSAPub(&chatPrivKey.PublicKey)) + encryptionPrivKeyHex := hex.EncodeToString(gethcrypto.FromECDSA(encryptionPrivKey)) whisperService, err := backend.StatusNode().WhisperService() require.NoError(t, err) @@ -243,7 +243,7 @@ func TestBackendInjectChatAccount(t *testing.T) { // wallet account should not be selected mainAccountAddress, err := backend.AccountManager().MainAccountAddress() - require.Equal(t, common.Address{}, mainAccountAddress) + require.Equal(t, types.Address{}, mainAccountAddress) require.Equal(t, account.ErrNoAccountSelected, err) // selected chat account should have the key injected previously @@ -526,9 +526,9 @@ func TestBackendGetVerifiedAccount(t *testing.T) { }() t.Run("AccountDoesntExist", func(t *testing.T) { - pkey, err := crypto.GenerateKey() + pkey, err := gethcrypto.GenerateKey() require.NoError(t, err) - address := crypto.PubkeyToAddress(pkey.PublicKey) + address := gethcrypto.PubkeyToAddress(pkey.PublicKey) key, err := backend.getVerifiedWalletAccount(address.String(), password) require.EqualError(t, err, transactions.ErrAccountDoesntExist.Error()) require.Nil(t, key) @@ -565,11 +565,11 @@ func TestLoginWithKey(t *testing.T) { utils.Init() b := NewGethStatusBackend() - chatKey, err := crypto.GenerateKey() + chatKey, err := gethcrypto.GenerateKey() require.NoError(t, err) - walletKey, err := crypto.GenerateKey() + walletKey, err := gethcrypto.GenerateKey() require.NoError(t, err) - keyUIDHex := sha256.Sum256(crypto.FromECDSAPub(&chatKey.PublicKey)) + keyUIDHex := sha256.Sum256(gethcrypto.FromECDSAPub(&chatKey.PublicKey)) keyUID := types.EncodeHex(keyUIDHex[:]) main := multiaccounts.Account{ KeyUID: keyUID, @@ -579,7 +579,7 @@ func TestLoginWithKey(t *testing.T) { defer os.Remove(tmpdir) conf, err := params.NewNodeConfig(tmpdir, 1777) require.NoError(t, err) - keyhex := hex.EncodeToString(crypto.FromECDSA(chatKey)) + keyhex := hex.EncodeToString(gethcrypto.FromECDSA(chatKey)) require.NoError(t, b.AccountManager().InitKeystore(conf.KeyStoreDir)) b.UpdateRootDataDir(conf.DataDir) diff --git a/api/geth_backend.go b/api/geth_backend.go index 39a79875b..135efd44a 100644 --- a/api/geth_backend.go +++ b/api/geth_backend.go @@ -655,7 +655,7 @@ func (b *GethStatusBackend) getVerifiedWalletAccount(address, password string) ( config := b.StatusNode().Config() db := accounts.NewDB(b.appDB) - exists, err := db.AddressExists(common.HexToAddress(address)) + exists, err := db.AddressExists(types.HexToAddress(address)) if err != nil { b.log.Error("failed to query db for a given address", "address", address, "error", err) return nil, err @@ -673,7 +673,7 @@ func (b *GethStatusBackend) getVerifiedWalletAccount(address, password string) ( } return &account.SelectedExtKey{ - Address: key.Address, + Address: types.Address(key.Address), AccountKey: key, }, nil } @@ -900,8 +900,10 @@ func (b *GethStatusBackend) startWallet() error { } allAddresses := make([]common.Address, len(watchAddresses)+1) - allAddresses[0] = mainAccountAddress - copy(allAddresses[1:], watchAddresses) + allAddresses[0] = common.Address(mainAccountAddress) + for i, addr := range watchAddresses { + allAddresses[1+i] = common.Address(addr) + } return wallet.StartReactor( b.statusNode.RPCClient().Ethclient(), allAddresses, diff --git a/lib/library_test_utils.go b/lib/library_test_utils.go index 78f57b528..0aba4cb4b 100644 --- a/lib/library_test_utils.go +++ b/lib/library_test_utils.go @@ -43,7 +43,6 @@ const initJS = ` };` var ( - zeroHash = common.Hash{} testChainDir string keystoreDir string nodeConfigJSON string @@ -61,7 +60,7 @@ func buildSubAccountData(chatAddress string) *C.char { { Wallet: true, Chat: true, - Address: common.HexToAddress(chatAddress), + Address: types.HexToAddress(chatAddress), }, } data, _ := json.Marshal(accs) @@ -70,9 +69,9 @@ func buildSubAccountData(chatAddress string) *C.char { func buildLoginParams(mainAccountAddress, chatAddress, password string) account.LoginParams { return account.LoginParams{ - ChatAddress: common.HexToAddress(chatAddress), + ChatAddress: types.HexToAddress(chatAddress), Password: password, - MainAccount: common.HexToAddress(mainAccountAddress), + MainAccount: types.HexToAddress(mainAccountAddress), } } @@ -536,8 +535,8 @@ func testSendTransactionWithLogin(t *testing.T, feed *event.Feed) bool { EnsureNodeSync(statusBackend.StatusNode().EnsureSync) args, err := json.Marshal(transactions.SendTxArgs{ - From: account.FromAddress(TestConfig.Account1.WalletAddress), - To: account.ToAddress(TestConfig.Account2.WalletAddress), + From: account.GethFromAddress(TestConfig.Account1.WalletAddress), + To: account.GethToAddress(TestConfig.Account2.WalletAddress), Value: (*hexutil.Big)(big.NewInt(1000000000000)), }) if err != nil { @@ -555,8 +554,8 @@ func testSendTransactionWithLogin(t *testing.T, feed *event.Feed) bool { t.Errorf("failed to send transaction: %v", result.Error) return false } - hash := common.BytesToHash(result.Result) - if reflect.DeepEqual(hash, common.Hash{}) { + hash := types.BytesToHash(result.Result) + if reflect.DeepEqual(hash, types.Hash{}) { t.Errorf("response hash empty: %s", hash.Hex()) return false } @@ -570,7 +569,7 @@ func testSendTransactionInvalidPassword(t *testing.T, feed *event.Feed) bool { args, err := json.Marshal(transactions.SendTxArgs{ From: common.HexToAddress(acc.WalletAddress), - To: account.ToAddress(TestConfig.Account2.WalletAddress), + To: account.GethToAddress(TestConfig.Account2.WalletAddress), Value: (*hexutil.Big)(big.NewInt(1000000000000)), }) if err != nil { @@ -597,8 +596,8 @@ func testFailedTransaction(t *testing.T, feed *event.Feed) bool { EnsureNodeSync(statusBackend.StatusNode().EnsureSync) args, err := json.Marshal(transactions.SendTxArgs{ - From: *account.ToAddress(TestConfig.Account1.WalletAddress), - To: account.ToAddress(TestConfig.Account2.WalletAddress), + From: *account.GethToAddress(TestConfig.Account1.WalletAddress), + To: account.GethToAddress(TestConfig.Account2.WalletAddress), Value: (*hexutil.Big)(big.NewInt(1000000000000)), }) if err != nil { diff --git a/multiaccounts/accounts/database.go b/multiaccounts/accounts/database.go index 1ce3fa1b4..63b68ebce 100644 --- a/multiaccounts/accounts/database.go +++ b/multiaccounts/accounts/database.go @@ -7,8 +7,7 @@ import ( "fmt" "strings" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/sqlite" ) @@ -25,13 +24,13 @@ var ( ) type Account struct { - Address common.Address `json:"address"` + Address types.Address `json:"address"` Wallet bool `json:"wallet"` Chat bool `json:"chat"` Type string `json:"type,omitempty"` Storage string `json:"storage,omitempty"` Path string `json:"path,omitempty"` - PublicKey hexutil.Bytes `json:"public-key,omitempty"` + PublicKey types.HexBytes `json:"public-key,omitempty"` Name string `json:"name"` Color string `json:"color"` } @@ -106,7 +105,7 @@ func (db *Database) GetAccounts() ([]Account, error) { return nil, err } if lth := len(pubkey); lth > 0 { - acc.PublicKey = make(hexutil.Bytes, lth) + acc.PublicKey = make(types.HexBytes, lth) copy(acc.PublicKey, pubkey) } accounts = append(accounts, acc) @@ -161,28 +160,28 @@ func (db *Database) SaveAccounts(accounts []Account) (err error) { return } -func (db *Database) DeleteAccount(address common.Address) error { +func (db *Database) DeleteAccount(address types.Address) error { _, err := db.db.Exec("DELETE FROM accounts WHERE address = ?", address) return err } -func (db *Database) GetWalletAddress() (rst common.Address, err error) { +func (db *Database) GetWalletAddress() (rst types.Address, err error) { err = db.db.QueryRow("SELECT address FROM accounts WHERE wallet = 1").Scan(&rst) return } -func (db *Database) GetChatAddress() (rst common.Address, err error) { +func (db *Database) GetChatAddress() (rst types.Address, err error) { err = db.db.QueryRow("SELECT address FROM accounts WHERE chat = 1").Scan(&rst) return } -func (db *Database) GetAddresses() (rst []common.Address, err error) { +func (db *Database) GetAddresses() (rst []types.Address, err error) { rows, err := db.db.Query("SELECT address FROM accounts ORDER BY created_at") if err != nil { return nil, err } for rows.Next() { - addr := common.Address{} + addr := types.Address{} err = rows.Scan(&addr) if err != nil { return nil, err @@ -193,7 +192,7 @@ func (db *Database) GetAddresses() (rst []common.Address, err error) { } // AddressExists returns true if given address is stored in database. -func (db *Database) AddressExists(address common.Address) (exists bool, err error) { +func (db *Database) AddressExists(address types.Address) (exists bool, err error) { err = db.db.QueryRow("SELECT EXISTS (SELECT 1 FROM accounts WHERE address = ?)", address).Scan(&exists) return exists, err } diff --git a/multiaccounts/accounts/database_test.go b/multiaccounts/accounts/database_test.go index 4a2b4d39a..8be6e513a 100644 --- a/multiaccounts/accounts/database_test.go +++ b/multiaccounts/accounts/database_test.go @@ -7,9 +7,8 @@ import ( "os" "testing" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/hexutil" "github.com/status-im/status-go/appdatabase" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/params" "github.com/stretchr/testify/require" ) @@ -80,23 +79,23 @@ func TestSaveAccounts(t *testing.T) { { description: "NoError", accounts: []Account{ - {Address: common.Address{0x01}, Chat: true, Wallet: true}, - {Address: common.Address{0x02}}, + {Address: types.Address{0x01}, Chat: true, Wallet: true}, + {Address: types.Address{0x02}}, }, }, { description: "UniqueChat", accounts: []Account{ - {Address: common.Address{0x01}, Chat: true}, - {Address: common.Address{0x02}, Chat: true}, + {Address: types.Address{0x01}, Chat: true}, + {Address: types.Address{0x02}, Chat: true}, }, err: ErrChatNotUnique, }, { description: "UniqueWallet", accounts: []Account{ - {Address: common.Address{0x01}, Wallet: true}, - {Address: common.Address{0x02}, Wallet: true}, + {Address: types.Address{0x01}, Wallet: true}, + {Address: types.Address{0x02}, Wallet: true}, }, err: ErrWalletNotUnique, }, @@ -113,8 +112,8 @@ func TestUpdateAccounts(t *testing.T) { db, stop := setupTestDB(t) defer stop() accounts := []Account{ - {Address: common.Address{0x01}, Chat: true, Wallet: true}, - {Address: common.Address{0x02}}, + {Address: types.Address{0x01}, Chat: true, Wallet: true}, + {Address: types.Address{0x02}}, } require.NoError(t, db.SaveAccounts(accounts)) accounts[0].Chat = false @@ -129,13 +128,13 @@ func TestDeleteAccount(t *testing.T) { db, stop := setupTestDB(t) defer stop() accounts := []Account{ - {Address: common.Address{0x01}, Chat: true, Wallet: true}, + {Address: types.Address{0x01}, Chat: true, Wallet: true}, } require.NoError(t, db.SaveAccounts(accounts)) rst, err := db.GetAccounts() require.NoError(t, err) require.Equal(t, 1, len(rst)) - require.NoError(t, db.DeleteAccount(common.Address{0x01})) + require.NoError(t, db.DeleteAccount(types.Address{0x01})) rst2, err := db.GetAccounts() require.NoError(t, err) require.Equal(t, 0, len(rst2)) @@ -145,19 +144,19 @@ func TestGetAddresses(t *testing.T) { db, stop := setupTestDB(t) defer stop() accounts := []Account{ - {Address: common.Address{0x01}, Chat: true, Wallet: true}, - {Address: common.Address{0x02}}, + {Address: types.Address{0x01}, Chat: true, Wallet: true}, + {Address: types.Address{0x02}}, } require.NoError(t, db.SaveAccounts(accounts)) addresses, err := db.GetAddresses() require.NoError(t, err) - require.Equal(t, []common.Address{{0x01}, {0x02}}, addresses) + require.Equal(t, []types.Address{{0x01}, {0x02}}, addresses) } func TestGetWalletAddress(t *testing.T) { db, stop := setupTestDB(t) defer stop() - address := common.Address{0x01} + address := types.Address{0x01} _, err := db.GetWalletAddress() require.Equal(t, err, sql.ErrNoRows) require.NoError(t, db.SaveAccounts([]Account{{Address: address, Wallet: true}})) @@ -169,7 +168,7 @@ func TestGetWalletAddress(t *testing.T) { func TestGetChatAddress(t *testing.T) { db, stop := setupTestDB(t) defer stop() - address := common.Address{0x01} + address := types.Address{0x01} _, err := db.GetChatAddress() require.Equal(t, err, sql.ErrNoRows) require.NoError(t, db.SaveAccounts([]Account{{Address: address, Chat: true}})) @@ -182,9 +181,9 @@ func TestGetAccounts(t *testing.T) { db, stop := setupTestDB(t) defer stop() accounts := []Account{ - {Address: common.Address{0x01}, Chat: true, Wallet: true}, - {Address: common.Address{0x02}, PublicKey: hexutil.Bytes{0x01, 0x02}}, - {Address: common.Address{0x03}, PublicKey: hexutil.Bytes{0x02, 0x03}}, + {Address: types.Address{0x01}, Chat: true, Wallet: true}, + {Address: types.Address{0x02}, PublicKey: types.HexBytes{0x01, 0x02}}, + {Address: types.Address{0x03}, PublicKey: types.HexBytes{0x02, 0x03}}, } require.NoError(t, db.SaveAccounts(accounts)) rst, err := db.GetAccounts() @@ -197,7 +196,7 @@ func TestAddressExists(t *testing.T) { defer stop() accounts := []Account{ - {Address: common.Address{0x01}, Chat: true, Wallet: true}, + {Address: types.Address{0x01}, Chat: true, Wallet: true}, } require.NoError(t, db.SaveAccounts(accounts)) @@ -209,7 +208,7 @@ func TestAddressExists(t *testing.T) { func TestAddressDoesntExist(t *testing.T) { db, stop := setupTestDB(t) defer stop() - exists, err := db.AddressExists(common.Address{1, 1, 1}) + exists, err := db.AddressExists(types.Address{1, 1, 1}) require.NoError(t, err) require.False(t, exists) } diff --git a/services/accounts/accounts.go b/services/accounts/accounts.go index cac28837d..b0c8db100 100644 --- a/services/accounts/accounts.go +++ b/services/accounts/accounts.go @@ -3,8 +3,8 @@ package accounts import ( "context" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/multiaccounts/accounts" ) @@ -31,6 +31,6 @@ func (api *API) GetAccounts(ctx context.Context) ([]accounts.Account, error) { return api.db.GetAccounts() } -func (api *API) DeleteAccount(ctx context.Context, address common.Address) error { +func (api *API) DeleteAccount(ctx context.Context, address types.Address) error { return api.db.DeleteAccount(address) } diff --git a/services/status/api.go b/services/status/api.go index 0c5011425..4724502de 100644 --- a/services/status/api.go +++ b/services/status/api.go @@ -5,8 +5,9 @@ import ( "errors" "fmt" - "github.com/ethereum/go-ethereum/common" "github.com/status-im/status-go/account" + + "github.com/status-im/status-go/eth-node/types" ) // PublicAPI represents a set of APIs from the `web3.status` namespace. @@ -42,9 +43,9 @@ func (api *PublicAPI) Login(context context.Context, req LoginRequest) (res Logi } loginParams := account.LoginParams{ - ChatAddress: common.HexToAddress(req.Addr), + ChatAddress: types.HexToAddress(req.Addr), Password: req.Password, - MainAccount: common.HexToAddress(req.Addr), + MainAccount: types.HexToAddress(req.Addr), } if err = api.s.am.SelectAccount(loginParams); err != nil { return diff --git a/services/status/api_test.go b/services/status/api_test.go index 249abfc74..40ca22f19 100644 --- a/services/status/api_test.go +++ b/services/status/api_test.go @@ -8,9 +8,9 @@ import ( "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/accounts/keystore" - "github.com/ethereum/go-ethereum/common" "github.com/golang/mock/gomock" "github.com/status-im/status-go/account" + "github.com/status-im/status-go/eth-node/types" "github.com/stretchr/testify/suite" ) @@ -53,8 +53,8 @@ var logintests = []struct { s.w.EXPECT().AddKeyPair(key.PrivateKey).Return("addressKey", nil) loginParams := account.LoginParams{ - MainAccount: common.HexToAddress("0x01"), - ChatAddress: common.HexToAddress("0x01"), + MainAccount: types.HexToAddress("0x01"), + ChatAddress: types.HexToAddress("0x01"), Password: "password", } s.am.EXPECT().SelectAccount(loginParams).Return(nil) @@ -95,8 +95,8 @@ var logintests = []struct { s.w.EXPECT().AddKeyPair(key.PrivateKey).Return("", nil) loginParams := account.LoginParams{ - MainAccount: common.HexToAddress("0x01"), - ChatAddress: common.HexToAddress("0x01"), + MainAccount: types.HexToAddress("0x01"), + ChatAddress: types.HexToAddress("0x01"), Password: "password", } s.am.EXPECT().SelectAccount(loginParams).Return(errors.New("foo")) diff --git a/services/wallet/service.go b/services/wallet/service.go index 5651a0c8e..8e5c8da87 100644 --- a/services/wallet/service.go +++ b/services/wallet/service.go @@ -121,9 +121,9 @@ func WatchAccountsChanges(ctx context.Context, feed *event.Feed, initial []commo log.Debug("wallet received updated list of accounts", "accounts", n) restart := false for _, acc := range n { - _, exist := listen[acc.Address] + _, exist := listen[common.Address(acc.Address)] if !exist { - listen[acc.Address] = struct{}{} + listen[common.Address(acc.Address)] = struct{}{} restart = true } } diff --git a/services/wallet/service_test.go b/services/wallet/service_test.go index b0540d471..fb1409caa 100644 --- a/services/wallet/service_test.go +++ b/services/wallet/service_test.go @@ -9,13 +9,15 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/core/types" + gethtypes "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/event" "github.com/status-im/status-go/multiaccounts/accounts" "github.com/status-im/status-go/t/devtests/testchain" "github.com/status-im/status-go/t/utils" "github.com/stretchr/testify/suite" + + "github.com/status-im/status-go/eth-node/types" ) func TestReactorChanges(t *testing.T) { @@ -34,9 +36,9 @@ type ReactorChangesSuite struct { first, second common.Address } -func (s *ReactorChangesSuite) txToAddress(nonce uint64, address common.Address) *types.Transaction { - tx := types.NewTransaction(nonce, address, big.NewInt(1e17), 21000, big.NewInt(1), nil) - tx, err := types.SignTx(tx, s.backend.Signer, s.backend.Faucet) +func (s *ReactorChangesSuite) txToAddress(nonce uint64, address common.Address) *gethtypes.Transaction { + tx := gethtypes.NewTransaction(nonce, address, big.NewInt(1e17), 21000, big.NewInt(1), nil) + tx, err := gethtypes.SignTx(tx, s.backend.Signer, s.backend.Faucet) s.Require().NoError(err) return tx } @@ -92,7 +94,7 @@ func (s *ReactorChangesSuite) TestWatchNewAccounts() { } return nil }, 5*time.Second, 500*time.Millisecond)) - s.feed.Send([]accounts.Account{{Address: s.first}, {Address: s.second}}) + s.feed.Send([]accounts.Account{{Address: types.Address(s.first)}, {Address: types.Address(s.second)}}) s.Require().NoError(utils.Eventually(func() error { transfers, err := s.db.GetTransfersByAddress(s.second, big.NewInt(0), nil) if err != nil { diff --git a/t/devtests/devnode.go b/t/devtests/devnode.go index 284ad3bb1..5388afadb 100644 --- a/t/devtests/devnode.go +++ b/t/devtests/devnode.go @@ -7,11 +7,11 @@ import ( "os" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/rpc" "github.com/status-im/status-go/api" + "github.com/status-im/status-go/eth-node/crypto" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/multiaccounts" "github.com/status-im/status-go/multiaccounts/accounts" @@ -29,7 +29,7 @@ type DevNodeSuite struct { Eth *ethclient.Client Local *statusrpc.Client DevAccount *ecdsa.PrivateKey - DevAccountAddress common.Address + DevAccountAddress types.Address dir string backend *api.GethStatusBackend @@ -42,7 +42,7 @@ func (s *DevNodeSuite) SetupTest() { s.Require().NoError(err) s.DevAccount = account s.DevAccountAddress = crypto.PubkeyToAddress(account.PublicKey) - s.miner, err = miner.NewDevNode(s.DevAccountAddress) + s.miner, err = miner.NewDevNode(common.Address(s.DevAccountAddress)) s.Require().NoError(err) s.Require().NoError(miner.StartWithMiner(s.miner)) diff --git a/t/devtests/tranfers_test.go b/t/devtests/tranfers_test.go index d1deee331..f5d59570a 100644 --- a/t/devtests/tranfers_test.go +++ b/t/devtests/tranfers_test.go @@ -10,7 +10,8 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" - "github.com/ethereum/go-ethereum/core/types" + gethtypes "github.com/ethereum/go-ethereum/core/types" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/services/wallet" "github.com/status-im/status-go/t/utils" "github.com/stretchr/testify/suite" @@ -28,10 +29,10 @@ func (s *TransfersSuite) getAllTranfers() (rst []wallet.TransferView, err error) return rst, s.Local.Call(&rst, "wallet_getTransfersByAddress", s.DevAccountAddress, (*hexutil.Big)(big.NewInt(0))) } -func (s *TransfersSuite) sendTx(nonce uint64, to common.Address) { - tx := types.NewTransaction(nonce, to, big.NewInt(1e18), 1e6, big.NewInt(10), nil) +func (s *TransfersSuite) sendTx(nonce uint64, to types.Address) { + tx := gethtypes.NewTransaction(nonce, common.Address(to), big.NewInt(1e18), 1e6, big.NewInt(10), nil) // TODO move signer to DevNodeSuite - tx, err := types.SignTx(tx, types.NewEIP155Signer(big.NewInt(1337)), s.DevAccount) + tx, err := gethtypes.SignTx(tx, gethtypes.NewEIP155Signer(big.NewInt(1337)), s.DevAccount) s.Require().NoError(err) s.Require().NoError(s.Eth.SendTransaction(context.Background(), tx)) timeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) diff --git a/t/e2e/accounts/accounts_test.go b/t/e2e/accounts/accounts_test.go index 090c07183..80d5691e8 100644 --- a/t/e2e/accounts/accounts_test.go +++ b/t/e2e/accounts/accounts_test.go @@ -6,20 +6,20 @@ import ( "fmt" "testing" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" "github.com/status-im/status-go/account" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/extkeys" "github.com/status-im/status-go/t/e2e" "github.com/status-im/status-go/t/utils" "github.com/stretchr/testify/suite" ) -func buildLoginParams(mainAccountAddress, chatAddress, password string, watchAddresses []common.Address) account.LoginParams { +func buildLoginParams(mainAccountAddress, chatAddress, password string, watchAddresses []types.Address) account.LoginParams { return account.LoginParams{ - ChatAddress: common.HexToAddress(chatAddress), + ChatAddress: types.HexToAddress(chatAddress), Password: password, - MainAccount: common.HexToAddress(mainAccountAddress), + MainAccount: types.HexToAddress(mainAccountAddress), WatchAddresses: watchAddresses, } } @@ -224,7 +224,7 @@ func (s *AccountsTestSuite) TestSelectedAccountOnRestart() { // make sure that no account is selected by default selectedWalletAccount, err := s.Backend.AccountManager().MainAccountAddress() s.EqualError(account.ErrNoAccountSelected, err.Error(), "account selected, but should not be") - s.Equal(common.Address{}, selectedWalletAccount) + s.Equal(types.Address{}, selectedWalletAccount) selectedChatAccount, err := s.Backend.AccountManager().SelectedChatAccount() s.EqualError(account.ErrNoAccountSelected, err.Error(), "account selected, but should not be") s.Nil(selectedChatAccount) @@ -234,9 +234,9 @@ func (s *AccountsTestSuite) TestSelectedAccountOnRestart() { expectedErr := errors.New("cannot retrieve a valid key for a given account: could not decrypt key with given password") s.EqualError(expectedErr, err.Error()) - watchAddresses := []common.Address{ - common.HexToAddress("0x00000000000000000000000000000000000001"), - common.HexToAddress("0x00000000000000000000000000000000000002"), + watchAddresses := []types.Address{ + types.HexToAddress("0x00000000000000000000000000000000000001"), + types.HexToAddress("0x00000000000000000000000000000000000002"), } s.NoError(s.Backend.SelectAccount(buildLoginParams(accountInfo2.WalletAddress, accountInfo2.ChatAddress, utils.TestConfig.Account1.Password, watchAddresses))) @@ -281,7 +281,7 @@ func (s *AccountsTestSuite) TestSelectedAccountOnRestart() { selectedWalletAccount, err = s.Backend.AccountManager().MainAccountAddress() s.EqualError(account.ErrNoAccountSelected, err.Error()) - s.Equal(common.Address{}, selectedWalletAccount) + s.Equal(types.Address{}, selectedWalletAccount) selectedChatAccount, err = s.Backend.AccountManager().SelectedChatAccount() s.EqualError(account.ErrNoAccountSelected, err.Error()) s.Nil(selectedChatAccount) diff --git a/t/e2e/transactions/transactions_test.go b/t/e2e/transactions/transactions_test.go index c927cfe01..ce5cfb8b5 100644 --- a/t/e2e/transactions/transactions_test.go +++ b/t/e2e/transactions/transactions_test.go @@ -7,10 +7,9 @@ import ( "reflect" "testing" - "github.com/ethereum/go-ethereum/common" - gethcommon "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/status-im/status-go/account" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/multiaccounts" "github.com/status-im/status-go/multiaccounts/accounts" "github.com/status-im/status-go/params" @@ -24,9 +23,9 @@ type initFunc func([]byte, *transactions.SendTxArgs) func buildLoginParams(mainAccountAddress, chatAddress, password string) account.LoginParams { return account.LoginParams{ - ChatAddress: common.HexToAddress(chatAddress), + ChatAddress: types.HexToAddress(chatAddress), Password: password, - MainAccount: common.HexToAddress(mainAccountAddress), + MainAccount: types.HexToAddress(mainAccountAddress), } } @@ -112,7 +111,7 @@ func (s *TransactionsTestSuite) TestEmptyToFieldPreserved() { s.Require().NoError(err) defer os.Remove(tmpdir) - wallet := common.HexToAddress(utils.TestConfig.Account1.WalletAddress) + wallet := types.HexToAddress(utils.TestConfig.Account1.WalletAddress) s.StartTestBackendWithAccount(multiaccounts.Account{KeyUID: utils.TestConfig.Account1.WalletAddress}, utils.TestConfig.Account1.Password, []accounts.Account{{Address: wallet, Wallet: true, Chat: true}}, e2e.WithDataDir(tmpdir), @@ -122,7 +121,7 @@ func (s *TransactionsTestSuite) TestEmptyToFieldPreserved() { utils.EnsureNodeSync(s.Backend.StatusNode().EnsureSync) args := transactions.SendTxArgs{ - From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), + From: account.GethFromAddress(utils.TestConfig.Account1.WalletAddress), } hash, err := s.Backend.SendTransaction(args, utils.TestConfig.Account1.Password) @@ -185,7 +184,7 @@ func (s *TransactionsTestSuite) testSendContractTx(setInputAndDataValue initFunc s.Require().NoError(err) defer os.Remove(tmpdir) - wallet := common.HexToAddress(utils.TestConfig.Account1.WalletAddress) + wallet := types.HexToAddress(utils.TestConfig.Account1.WalletAddress) s.StartTestBackendWithAccount(multiaccounts.Account{KeyUID: utils.TestConfig.Account1.WalletAddress}, utils.TestConfig.Account1.Password, []accounts.Account{{Address: wallet, Wallet: true, Chat: true}}, e2e.WithDataDir(tmpdir), @@ -195,14 +194,14 @@ func (s *TransactionsTestSuite) testSendContractTx(setInputAndDataValue initFunc utils.EnsureNodeSync(s.Backend.StatusNode().EnsureSync) // this call blocks, up until Complete Transaction is called - byteCode, err := hexutil.Decode(`0x6060604052341561000c57fe5b5b60a58061001b6000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680636ffa1caa14603a575bfe5b3415604157fe5b60556004808035906020019091905050606b565b6040518082815260200191505060405180910390f35b60008160020290505b9190505600a165627a7a72305820ccdadd737e4ac7039963b54cee5e5afb25fa859a275252bdcf06f653155228210029`) + byteCode, err := types.DecodeHex(`0x6060604052341561000c57fe5b5b60a58061001b6000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680636ffa1caa14603a575bfe5b3415604157fe5b60556004808035906020019091905050606b565b6040518082815260200191505060405180910390f35b60008160020290505b9190505600a165627a7a72305820ccdadd737e4ac7039963b54cee5e5afb25fa859a275252bdcf06f653155228210029`) s.NoError(err) gas := uint64(params.DefaultGas) args := transactions.SendTxArgs{ - From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), + From: account.GethFromAddress(utils.TestConfig.Account1.WalletAddress), To: nil, // marker, contract creation is expected - //Value: (*hexutil.Big)(new(big.Int).Mul(big.NewInt(1), gethcommon.Ether)), + //Value: (*hexutil.Big)(new(big.Int).Mul(big.NewInt(1), common.Ether)), Gas: (*hexutil.Uint64)(&gas), } @@ -213,7 +212,7 @@ func (s *TransactionsTestSuite) testSendContractTx(setInputAndDataValue initFunc return } s.NoError(err) - s.False(reflect.DeepEqual(hash, gethcommon.Hash{})) + s.False(reflect.DeepEqual(hash, types.Hash{})) } func (s *TransactionsTestSuite) TestSendEther() { @@ -222,7 +221,7 @@ func (s *TransactionsTestSuite) TestSendEther() { s.Require().NoError(err) defer os.Remove(tmpdir) - wallet := common.HexToAddress(utils.TestConfig.Account1.WalletAddress) + wallet := types.HexToAddress(utils.TestConfig.Account1.WalletAddress) s.StartTestBackendWithAccount(multiaccounts.Account{KeyUID: utils.TestConfig.Account1.WalletAddress}, utils.TestConfig.Account1.Password, []accounts.Account{{Address: wallet, Wallet: true, Chat: true}}, e2e.WithDataDir(tmpdir), @@ -232,12 +231,12 @@ func (s *TransactionsTestSuite) TestSendEther() { utils.EnsureNodeSync(s.Backend.StatusNode().EnsureSync) hash, err := s.Backend.SendTransaction(transactions.SendTxArgs{ - From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), - To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), + From: account.GethFromAddress(utils.TestConfig.Account1.WalletAddress), + To: account.GethToAddress(utils.TestConfig.Account2.WalletAddress), Value: (*hexutil.Big)(big.NewInt(1000000000000)), }, utils.TestConfig.Account1.Password) s.NoError(err) - s.False(reflect.DeepEqual(hash, gethcommon.Hash{})) + s.False(reflect.DeepEqual(hash, types.Hash{})) } func (s *TransactionsTestSuite) TestSendEtherTxUpstream() { @@ -249,7 +248,7 @@ func (s *TransactionsTestSuite) TestSendEtherTxUpstream() { addr, err := utils.GetRemoteURL() s.NoError(err) - wallet := common.HexToAddress(utils.TestConfig.Account1.WalletAddress) + wallet := types.HexToAddress(utils.TestConfig.Account1.WalletAddress) s.StartTestBackendWithAccount(multiaccounts.Account{KeyUID: utils.TestConfig.Account1.WalletAddress}, utils.TestConfig.Account1.Password, []accounts.Account{{Address: wallet, Wallet: true, Chat: true}}, e2e.WithUpstream(addr), @@ -258,11 +257,11 @@ func (s *TransactionsTestSuite) TestSendEtherTxUpstream() { defer s.LogoutAndStop() hash, err := s.Backend.SendTransaction(transactions.SendTxArgs{ - From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), - To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), + From: account.GethFromAddress(utils.TestConfig.Account1.WalletAddress), + To: account.GethToAddress(utils.TestConfig.Account2.WalletAddress), GasPrice: (*hexutil.Big)(big.NewInt(28000000000)), Value: (*hexutil.Big)(big.NewInt(1000000000000)), }, utils.TestConfig.Account1.Password) s.NoError(err) - s.False(reflect.DeepEqual(hash, gethcommon.Hash{})) + s.False(reflect.DeepEqual(hash, types.Hash{})) } diff --git a/t/e2e/whisper/whisper_test.go b/t/e2e/whisper/whisper_test.go index ce569f2b0..863518ddb 100644 --- a/t/e2e/whisper/whisper_test.go +++ b/t/e2e/whisper/whisper_test.go @@ -5,10 +5,9 @@ import ( "errors" "testing" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/crypto" "github.com/status-im/status-go/account" + "github.com/status-im/status-go/eth-node/types" e2e "github.com/status-im/status-go/t/e2e" . "github.com/status-im/status-go/t/utils" "github.com/status-im/status-go/whisper/v6" @@ -25,9 +24,9 @@ type WhisperTestSuite struct { func buildLoginParams(mainAccountAddress, chatAddress, password string) account.LoginParams { return account.LoginParams{ - ChatAddress: common.HexToAddress(chatAddress), + ChatAddress: types.HexToAddress(chatAddress), Password: password, - MainAccount: common.HexToAddress(mainAccountAddress), + MainAccount: types.HexToAddress(mainAccountAddress), } } @@ -170,7 +169,7 @@ func (s *WhisperTestSuite) TestSelectedAccountOnRestart() { // make sure that no wallet account is selected by default selectedWalletAccount, err := s.Backend.AccountManager().MainAccountAddress() s.EqualError(account.ErrNoAccountSelected, err.Error(), "account selected, but should not be") - s.Equal(common.Address{}, selectedWalletAccount) + s.Equal(types.Address{}, selectedWalletAccount) // make sure that no chat account is selected by default selectedChatAccount, err := s.Backend.AccountManager().SelectedChatAccount() @@ -186,7 +185,7 @@ func (s *WhisperTestSuite) TestSelectedAccountOnRestart() { s.NoError(s.Backend.SelectAccount(buildLoginParams(accountInfo1.WalletAddress, accountInfo1.ChatAddress, TestConfig.Account1.Password))) selectedChatAccount1, err := s.Backend.AccountManager().SelectedChatAccount() s.NoError(err) - selectedChatPubKey1 := hexutil.Encode(crypto.FromECDSAPub(&selectedChatAccount1.AccountKey.PrivateKey.PublicKey)) + selectedChatPubKey1 := types.EncodeHex(crypto.FromECDSAPub(&selectedChatAccount1.AccountKey.PrivateKey.PublicKey)) s.Equal(selectedChatPubKey1, accountInfo1.ChatPubKey) s.True(whisperService.HasKeyPair(selectedChatPubKey1), "identity not injected into whisper") @@ -195,7 +194,7 @@ func (s *WhisperTestSuite) TestSelectedAccountOnRestart() { s.NoError(s.Backend.SelectAccount(buildLoginParams(accountInfo2.WalletAddress, accountInfo2.ChatAddress, TestConfig.Account2.Password))) selectedChatAccount2, err := s.Backend.AccountManager().SelectedChatAccount() s.NoError(err) - selectedChatPubKey2 := hexutil.Encode(crypto.FromECDSAPub(&selectedChatAccount2.AccountKey.PrivateKey.PublicKey)) + selectedChatPubKey2 := types.EncodeHex(crypto.FromECDSAPub(&selectedChatAccount2.AccountKey.PrivateKey.PublicKey)) s.Equal(selectedChatPubKey2, accountInfo2.ChatPubKey) s.True(whisperService.HasKeyPair(selectedChatPubKey2), "identity not injected into whisper") s.False(whisperService.HasKeyPair(selectedChatPubKey1), "identity should be removed, but it is still present in whisper") @@ -241,7 +240,7 @@ func (s *WhisperTestSuite) TestSelectedAccountOnRestart() { selectedWalletAccount, err = s.Backend.AccountManager().MainAccountAddress() s.EqualError(account.ErrNoAccountSelected, err.Error()) - s.Equal(common.Address{}, selectedWalletAccount) + s.Equal(types.Address{}, selectedWalletAccount) selectedChatAccount, err = s.Backend.AccountManager().SelectedChatAccount() s.EqualError(account.ErrNoAccountSelected, err.Error()) @@ -267,6 +266,6 @@ func (s *WhisperTestSuite) TestSelectedChatKeyIsUsedInWhisper() { s.NoError(err) // chat key should be injected in whisper - selectedChatPubKey := hexutil.Encode(crypto.FromECDSAPub(&selectedChatAccount.AccountKey.PrivateKey.PublicKey)) + selectedChatPubKey := types.EncodeHex(crypto.FromECDSAPub(&selectedChatAccount.AccountKey.PrivateKey.PublicKey)) s.True(whisperService.HasKeyPair(selectedChatPubKey), "identity not injected in whisper") } diff --git a/transactions/transactor_test.go b/transactions/transactor_test.go index be6f7e0f6..789f13bc9 100644 --- a/transactions/transactor_test.go +++ b/transactions/transactor_test.go @@ -13,17 +13,17 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/accounts/keystore" "github.com/ethereum/go-ethereum/common" - gethcommon "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" + gethtypes "github.com/ethereum/go-ethereum/core/types" + gethcrypto "github.com/ethereum/go-ethereum/crypto" gethparams "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" gethrpc "github.com/ethereum/go-ethereum/rpc" "github.com/golang/mock/gomock" "github.com/status-im/status-go/account" "github.com/status-im/status-go/contracts/ens/contract" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/params" "github.com/status-im/status-go/rpc" "github.com/status-im/status-go/t/utils" @@ -82,7 +82,7 @@ func (s *TransactorSuite) setupTransactionPoolAPI(args SendTxArgs, returnNonce, // And also set the expected gas and gas price for RLP encoding the expected tx. var usedGas hexutil.Uint64 var usedGasPrice *big.Int - s.txServiceMock.EXPECT().GetTransactionCount(gomock.Any(), account.Address, gethrpc.PendingBlockNumber).Return(&returnNonce, nil) + s.txServiceMock.EXPECT().GetTransactionCount(gomock.Any(), gomock.Eq(common.Address(account.Address)), gethrpc.PendingBlockNumber).Return(&returnNonce, nil) if args.GasPrice == nil { usedGasPrice = (*big.Int)(testGasPrice) s.txServiceMock.EXPECT().GasPrice(gomock.Any()).Return(testGasPrice, nil) @@ -98,11 +98,11 @@ func (s *TransactorSuite) setupTransactionPoolAPI(args SendTxArgs, returnNonce, // Prepare the transaction and RLP encode it. data := s.rlpEncodeTx(args, s.nodeConfig, account, &resultNonce, usedGas, usedGasPrice) // Expect the RLP encoded transaction. - s.txServiceMock.EXPECT().SendRawTransaction(gomock.Any(), data).Return(gethcommon.Hash{}, txErr) + s.txServiceMock.EXPECT().SendRawTransaction(gomock.Any(), data).Return(common.Hash{}, txErr) } func (s *TransactorSuite) rlpEncodeTx(args SendTxArgs, config *params.NodeConfig, account *account.SelectedExtKey, nonce *hexutil.Uint64, gas hexutil.Uint64, gasPrice *big.Int) hexutil.Bytes { - newTx := types.NewTransaction( + newTx := gethtypes.NewTransaction( uint64(*nonce), *args.To, args.Value.ToInt(), @@ -111,7 +111,7 @@ func (s *TransactorSuite) rlpEncodeTx(args SendTxArgs, config *params.NodeConfig []byte(args.Input), ) chainID := big.NewInt(int64(config.NetworkID)) - signedTx, err := types.SignTx(newTx, types.NewEIP155Signer(chainID), account.AccountKey.PrivateKey) + signedTx, err := gethtypes.SignTx(newTx, gethtypes.NewEIP155Signer(chainID), account.AccountKey.PrivateKey) s.NoError(err) data, err := rlp.EncodeToBytes(signedTx) s.NoError(err) @@ -119,7 +119,7 @@ func (s *TransactorSuite) rlpEncodeTx(args SendTxArgs, config *params.NodeConfig } func (s *TransactorSuite) TestGasValues() { - key, _ := crypto.GenerateKey() + key, _ := gethcrypto.GenerateKey() selectedAccount := &account.SelectedExtKey{ Address: account.FromAddress(utils.TestConfig.Account1.WalletAddress), AccountKey: &keystore.Key{PrivateKey: key}, @@ -155,8 +155,8 @@ func (s *TransactorSuite) TestGasValues() { s.T().Run(testCase.name, func(t *testing.T) { s.SetupTest() args := SendTxArgs{ - From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), - To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), + From: account.GethFromAddress(utils.TestConfig.Account1.WalletAddress), + To: account.GethToAddress(utils.TestConfig.Account2.WalletAddress), Gas: testCase.gas, GasPrice: testCase.gasPrice, } @@ -164,15 +164,15 @@ func (s *TransactorSuite) TestGasValues() { hash, err := s.manager.SendTransaction(args, selectedAccount) s.NoError(err) - s.False(reflect.DeepEqual(hash, gethcommon.Hash{})) + s.False(reflect.DeepEqual(hash, common.Hash{})) }) } } func (s *TransactorSuite) TestArgsValidation() { args := SendTxArgs{ - From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), - To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), + From: account.GethFromAddress(utils.TestConfig.Account1.WalletAddress), + To: account.GethToAddress(utils.TestConfig.Account2.WalletAddress), Data: hexutil.Bytes([]byte{0x01, 0x02}), Input: hexutil.Bytes([]byte{0x02, 0x01}), } @@ -186,8 +186,8 @@ func (s *TransactorSuite) TestArgsValidation() { func (s *TransactorSuite) TestAccountMismatch() { args := SendTxArgs{ - From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), - To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), + From: account.GethFromAddress(utils.TestConfig.Account1.WalletAddress), + To: account.GethToAddress(utils.TestConfig.Account2.WalletAddress), } var err error @@ -213,7 +213,7 @@ func (s *TransactorSuite) TestAccountMismatch() { // as the last step, we verify that if tx failed nonce is not updated func (s *TransactorSuite) TestLocalNonce() { txCount := 3 - key, _ := crypto.GenerateKey() + key, _ := gethcrypto.GenerateKey() selectedAccount := &account.SelectedExtKey{ Address: account.FromAddress(utils.TestConfig.Account1.WalletAddress), AccountKey: &keystore.Key{PrivateKey: key}, @@ -222,8 +222,8 @@ func (s *TransactorSuite) TestLocalNonce() { for i := 0; i < txCount; i++ { args := SendTxArgs{ - From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), - To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), + From: account.GethFromAddress(utils.TestConfig.Account1.WalletAddress), + To: account.GethToAddress(utils.TestConfig.Account2.WalletAddress), } s.setupTransactionPoolAPI(args, nonce, hexutil.Uint64(i), selectedAccount, nil) @@ -235,8 +235,8 @@ func (s *TransactorSuite) TestLocalNonce() { nonce = hexutil.Uint64(5) args := SendTxArgs{ - From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), - To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), + From: account.GethFromAddress(utils.TestConfig.Account1.WalletAddress), + To: account.GethToAddress(utils.TestConfig.Account2.WalletAddress), } s.setupTransactionPoolAPI(args, nonce, nonce, selectedAccount, nil) @@ -248,10 +248,10 @@ func (s *TransactorSuite) TestLocalNonce() { s.Equal(uint64(nonce)+1, resultNonce.(uint64)) testErr := errors.New("test") - s.txServiceMock.EXPECT().GetTransactionCount(gomock.Any(), selectedAccount.Address, gethrpc.PendingBlockNumber).Return(nil, testErr) + s.txServiceMock.EXPECT().GetTransactionCount(gomock.Any(), gomock.Eq(common.Address(selectedAccount.Address)), gethrpc.PendingBlockNumber).Return(nil, testErr) args = SendTxArgs{ - From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), - To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), + From: account.GethFromAddress(utils.TestConfig.Account1.WalletAddress), + To: account.GethToAddress(utils.TestConfig.Account2.WalletAddress), } _, err = s.manager.SendTransaction(args, selectedAccount) @@ -261,14 +261,14 @@ func (s *TransactorSuite) TestLocalNonce() { } func (s *TransactorSuite) TestContractCreation() { - key, _ := crypto.GenerateKey() - testaddr := crypto.PubkeyToAddress(key.PublicKey) + key, _ := gethcrypto.GenerateKey() + testaddr := gethcrypto.PubkeyToAddress(key.PublicKey) genesis := core.GenesisAlloc{ testaddr: {Balance: big.NewInt(100000000000)}, } backend := backends.NewSimulatedBackend(genesis, math.MaxInt64) selectedAccount := &account.SelectedExtKey{ - Address: testaddr, + Address: types.Address(testaddr), AccountKey: &keystore.Key{PrivateKey: key}, } s.manager.sender = backend @@ -276,7 +276,7 @@ func (s *TransactorSuite) TestContractCreation() { s.manager.pendingNonceProvider = backend tx := SendTxArgs{ From: testaddr, - Input: hexutil.Bytes(gethcommon.FromHex(contract.ENSBin)), + Input: hexutil.Bytes(common.FromHex(contract.ENSBin)), } hash, err := s.manager.SendTransaction(tx, selectedAccount) @@ -284,13 +284,13 @@ func (s *TransactorSuite) TestContractCreation() { backend.Commit() receipt, err := backend.TransactionReceipt(context.TODO(), common.Hash(hash)) s.NoError(err) - s.Equal(crypto.CreateAddress(testaddr, 0), receipt.ContractAddress) + s.Equal(gethcrypto.CreateAddress(testaddr, 0), receipt.ContractAddress) } func (s *TransactorSuite) TestSendTransactionWithSignature() { - privKey, err := crypto.GenerateKey() + privKey, err := gethcrypto.GenerateKey() s.Require().NoError(err) - address := crypto.PubkeyToAddress(privKey.PublicKey) + address := gethcrypto.PubkeyToAddress(privKey.PublicKey) scenarios := []struct { localNonce hexutil.Uint64 @@ -339,10 +339,10 @@ func (s *TransactorSuite) TestSendTransactionWithSignature() { } // simulate transaction signed externally - signer := types.NewEIP155Signer(chainID) - tx := types.NewTransaction(uint64(nonce), to, (*big.Int)(value), uint64(gas), (*big.Int)(gasPrice), data) + signer := gethtypes.NewEIP155Signer(chainID) + tx := gethtypes.NewTransaction(uint64(nonce), to, (*big.Int)(value), uint64(gas), (*big.Int)(gasPrice), data) hash := signer.Hash(tx) - sig, err := crypto.Sign(hash[:], privKey) + sig, err := gethcrypto.Sign(hash[:], privKey) s.Require().NoError(err) txWithSig, err := tx.WithSignature(signer, sig) s.Require().NoError(err) @@ -356,7 +356,7 @@ func (s *TransactorSuite) TestSendTransactionWithSignature() { if !scenario.expectError { s.txServiceMock.EXPECT(). SendRawTransaction(gomock.Any(), hexutil.Bytes(expectedEncodedTx)). - Return(gethcommon.Hash{}, nil) + Return(common.Hash{}, nil) } _, err = s.manager.SendTransactionWithSignature(args, sig) @@ -382,9 +382,9 @@ func (s *TransactorSuite) TestSendTransactionWithSignature_InvalidSignature() { } func (s *TransactorSuite) TestHashTransaction() { - privKey, err := crypto.GenerateKey() + privKey, err := gethcrypto.GenerateKey() s.Require().NoError(err) - address := crypto.PubkeyToAddress(privKey.PublicKey) + address := gethcrypto.PubkeyToAddress(privKey.PublicKey) remoteNonce := hexutil.Uint64(1) txNonce := hexutil.Uint64(0)