github.com/status-im/status-go@v1.1.0/multiaccounts/accounts/database_test.go

package accounts

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/status-im/status-go/appdatabase"
	"github.com/status-im/status-go/eth-node/types"
	"github.com/status-im/status-go/multiaccounts/common"
	"github.com/status-im/status-go/multiaccounts/settings"
	"github.com/status-im/status-go/params"
	"github.com/status-im/status-go/t/helpers"
)

func setupTestDB(t *testing.T) (*Database, func()) {
	db, stop, err := helpers.SetupTestSQLDB(appdatabase.DbInitializer{}, "settings-tests-")
	require.NoError(t, err)
	d, err := NewDB(db)
	require.NoError(t, err)
	return d, func() { require.NoError(t, stop()) }
}

func TestGetAddresses(t *testing.T) {
	db, stop := setupTestDB(t)
	defer stop()
	accounts := []*Account{
		{Address: types.Address{0x01}, Chat: true, Wallet: true},
		{Address: types.Address{0x02}},
	}
	require.NoError(t, db.SaveOrUpdateAccounts(accounts, false))
	addresses, err := db.GetAddresses()
	require.NoError(t, err)
	require.Equal(t, []types.Address{{0x01}, {0x02}}, addresses)
}

func TestMoveWalletAccount(t *testing.T) {
	db, stop := setupTestDB(t)
	defer stop()

	networks := json.RawMessage("{}")
	setting := settings.Settings{
		Networks: &networks,
	}
	config := params.NodeConfig{}
	err := db.CreateSettings(setting, config)
	require.NoError(t, err)

	accounts := []*Account{
		{Address: types.Address{0x01}, Type: AccountTypeWatch, Position: 0},
		{Address: types.Address{0x02}, Type: AccountTypeWatch, Position: 1},
		{Address: types.Address{0x03}, Type: AccountTypeWatch, Position: 2},
		{Address: types.Address{0x04}, Type: AccountTypeWatch, Position: 3},
		{Address: types.Address{0x05}, Type: AccountTypeWatch, Position: 4},
		{Address: types.Address{0x06}, Type: AccountTypeWatch, Position: 5},
	}
	require.NoError(t, db.SaveOrUpdateAccounts(accounts, false))
	dbAccounts, err := db.GetActiveAccounts()
	require.NoError(t, err)
	require.Len(t, dbAccounts, len(accounts))
	for i := 0; i < len(accounts); i++ {
		require.True(t, SameAccounts(accounts[i], dbAccounts[i]))
	}

	clock := uint64(1000)
	err = db.MoveWalletAccount(-1, 4, clock)
	require.ErrorIs(t, err, ErrMovingAccountToWrongPosition)
	err = db.MoveWalletAccount(4, -1, clock)
	require.ErrorIs(t, err, ErrMovingAccountToWrongPosition)
	err = db.MoveWalletAccount(4, 4, clock)
	require.ErrorIs(t, err, ErrMovingAccountToWrongPosition)

	// Move down account from position 1 to position 4
	err = db.MoveWalletAccount(1, 4, clock)
	require.NoError(t, err)

	// Expected after moving down
	accounts = []*Account{
		{Address: types.Address{0x01}, Type: AccountTypeWatch, Position: 0},
		{Address: types.Address{0x03}, Type: AccountTypeWatch, Position: 1},
		{Address: types.Address{0x04}, Type: AccountTypeWatch, Position: 2},
		{Address: types.Address{0x05}, Type: AccountTypeWatch, Position: 3},
		{Address: types.Address{0x02}, Type: AccountTypeWatch, Position: 4}, // acc with addr 0x02 is at position 4 (moved from position 1)
		{Address: types.Address{0x06}, Type: AccountTypeWatch, Position: 5},
	}

	dbAccounts, err = db.GetActiveAccounts()
	require.NoError(t, err)
	for i := 0; i < len(accounts); i++ {
		require.True(t, SameAccounts(accounts[i], dbAccounts[i]))
	}

	// Check clock
	dbClock, err := db.GetClockOfLastAccountsPositionChange()
	require.NoError(t, err)
	require.Equal(t, clock, dbClock)

	// Move up account from position 5 to position 0
	clock = 2000
	err = db.MoveWalletAccount(5, 0, clock)
	require.NoError(t, err)

	// Expected after moving up
	accounts = []*Account{
		{Address: types.Address{0x06}, Type: AccountTypeWatch, Position: 0}, // acc with addr 0x06 is at position 0 (moved from position 5)
		{Address: types.Address{0x01}, Type: AccountTypeWatch, Position: 1},
		{Address: types.Address{0x03}, Type: AccountTypeWatch, Position: 2},
		{Address: types.Address{0x04}, Type: AccountTypeWatch, Position: 3},
		{Address: types.Address{0x05}, Type: AccountTypeWatch, Position: 4},
		{Address: types.Address{0x02}, Type: AccountTypeWatch, Position: 5},
	}

	dbAccounts, err = db.GetActiveAccounts()
	require.NoError(t, err)
	for i := 0; i < len(accounts); i++ {
		require.True(t, SameAccounts(accounts[i], dbAccounts[i]))
	}

	// Check clock
	dbClock, err = db.GetClockOfLastAccountsPositionChange()
	require.NoError(t, err)
	require.Equal(t, clock, dbClock)
}

func TestGetWalletAddress(t *testing.T) {
	db, stop := setupTestDB(t)
	defer stop()
	address := types.Address{0x01}
	_, err := db.GetWalletAddress()
	require.Equal(t, err, sql.ErrNoRows)
	require.NoError(t, db.SaveOrUpdateAccounts([]*Account{{Address: address, Wallet: true}}, false))
	wallet, err := db.GetWalletAddress()
	require.NoError(t, err)
	require.Equal(t, address, wallet)
}

func TestGetChatAddress(t *testing.T) {
	db, stop := setupTestDB(t)
	defer stop()
	address := types.Address{0x01}
	_, err := db.GetChatAddress()
	require.Equal(t, err, sql.ErrNoRows)
	require.NoError(t, db.SaveOrUpdateAccounts([]*Account{{Address: address, Chat: true}}, false))
	chat, err := db.GetChatAddress()
	require.NoError(t, err)
	require.Equal(t, address, chat)
}

func TestAddressExists(t *testing.T) {
	db, stop := setupTestDB(t)
	defer stop()

	accounts := []*Account{
		{Address: types.Address{0x01}, Chat: true, Wallet: true},
	}
	require.NoError(t, db.SaveOrUpdateAccounts(accounts, false))

	exists, err := db.AddressExists(accounts[0].Address)
	require.NoError(t, err)
	require.True(t, exists)
}

func TestAddressDoesntExist(t *testing.T) {
	db, stop := setupTestDB(t)
	defer stop()
	exists, err := db.AddressExists(types.Address{1, 1, 1})
	require.NoError(t, err)
	require.False(t, exists)
}

func TestWatchOnlyAccounts(t *testing.T) {
	db, stop := setupTestDB(t)
	defer stop()

	// check the db
	dbAccounts, err := db.GetActiveAccounts()
	require.NoError(t, err)
	require.Equal(t, 0, len(dbAccounts))

	woAccounts := GetWatchOnlyAccountsForTest()

	// try to save keypair with watch only accounts
	kp := &Keypair{}
	kp.Accounts = append(kp.Accounts, woAccounts...)
	err = db.SaveOrUpdateKeypair(kp)
	require.Error(t, err)

	// check the db after that trying to save keypair with watch only accounts
	dbAccounts, err = db.GetActiveAccounts()
	require.NoError(t, err)
	require.Equal(t, 0, len(dbAccounts))

	// save watch only accounts
	err = db.SaveOrUpdateAccounts(woAccounts, false)
	require.NoError(t, err)
	_, err = db.GetKeypairByKeyUID(woAccounts[0].KeyUID)
	require.Error(t, err)
	require.True(t, err == ErrDbKeypairNotFound)
	dbAccounts, err = db.GetActiveAccounts()
	require.NoError(t, err)
	require.Equal(t, len(woAccounts), len(dbAccounts))
	require.Equal(t, woAccounts[0].Address, dbAccounts[0].Address)

	// try to save the same watch only account again
	err = db.SaveOrUpdateAccounts(woAccounts[:1], false)
	require.NoError(t, err)
	dbAccounts, err = db.GetActiveAccounts()
	require.NoError(t, err)
	require.Equal(t, len(woAccounts), len(dbAccounts))
	dbAcc, err := db.GetAccountByAddress(woAccounts[:1][0].Address)
	require.NoError(t, err)
	require.Equal(t, woAccounts[:1][0].Address, dbAcc.Address)

	// try to save new watch only account
	wo4 := &Account{
		Address: types.Address{0x14},
		Type:    AccountTypeWatch,
		Name:    "WatchOnlyAcc4",
		ColorID: common.CustomizationColorPrimary,
		Emoji:   "emoji-1",
	}
	err = db.SaveOrUpdateAccounts([]*Account{wo4}, false)
	require.NoError(t, err)
	dbAccounts, err = db.GetActiveAccounts()
	require.NoError(t, err)
	require.Equal(t, len(woAccounts)+1, len(dbAccounts))
	dbAcc, err = db.GetAccountByAddress(wo4.Address)
	require.NoError(t, err)
	require.Equal(t, wo4.Address, dbAcc.Address)

	// updated watch onl to save the same account after it's saved
	wo4.Name = wo4.Name + "updated"
	wo4.ColorID = common.CustomizationColorCamel
	wo4.Emoji = wo4.Emoji + "updated"
	err = db.SaveOrUpdateAccounts([]*Account{wo4}, false)
	require.NoError(t, err)
	dbAccounts, err = db.GetActiveAccounts()
	require.NoError(t, err)
	require.Equal(t, len(woAccounts)+1, len(dbAccounts))
	dbAcc, err = db.GetAccountByAddress(wo4.Address)
	require.NoError(t, err)
	require.Equal(t, wo4.Address, dbAcc.Address)

	// try to delete keypair for watch only account
	err = db.RemoveKeypair(wo4.KeyUID, 0)
	require.Error(t, err)
	require.True(t, err == ErrDbKeypairNotFound)

	// try to delete watch only account
	err = db.RemoveAccount(wo4.Address, 0)
	require.NoError(t, err)
	dbAccounts, err = db.GetActiveAccounts()
	require.NoError(t, err)
	require.Equal(t, len(woAccounts), len(dbAccounts))
	_, err = db.GetAccountByAddress(wo4.Address)
	require.Error(t, err)
	require.True(t, err == ErrDbAccountNotFound)
}

func TestUpdateKeypairName(t *testing.T) {
	db, stop := setupTestDB(t)
	defer stop()

	kp := GetProfileKeypairForTest(true, false, false)

	// check the db
	dbAccounts, err := db.GetActiveAccounts()
	require.NoError(t, err)
	require.Equal(t, 0, len(dbAccounts))

	// save keypair
	err = db.SaveOrUpdateKeypair(kp)
	require.NoError(t, err)
	dbKeypairs, err := db.GetActiveKeypairs()
	require.NoError(t, err)
	require.Equal(t, 1, len(dbKeypairs))
	require.True(t, SameKeypairs(kp, dbKeypairs[0]))

	// update keypair name
	kp.Name = kp.Name + "updated"
	kp.Accounts[0].Name = kp.Name
	err = db.UpdateKeypairName(kp.KeyUID, kp.Name, kp.Clock, true)
	require.NoError(t, err)

	// check keypair
	dbKp, err := db.GetKeypairByKeyUID(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, len(kp.Accounts), len(dbKp.Accounts))
	require.True(t, SameKeypairs(kp, dbKp))
}

func TestKeypairs(t *testing.T) {
	keypairs := []*Keypair{
		GetProfileKeypairForTest(true, true, true),
		GetSeedImportedKeypair1ForTest(),
		GetPrivKeyImportedKeypairForTest(), // in this context (when testing db functions) there is not limitations for private key imported keypair
	}

	for _, kp := range keypairs {
		t.Run("test keypair "+kp.Name, func(t *testing.T) {
			db, stop := setupTestDB(t)
			defer stop()

			// check the db
			dbKeypairs, err := db.GetActiveKeypairs()
			require.NoError(t, err)
			require.Equal(t, 0, len(dbKeypairs))
			dbAccounts, err := db.GetActiveAccounts()
			require.NoError(t, err)
			require.Equal(t, 0, len(dbAccounts))

			expectedLastUsedDerivationIndex := uint64(len(kp.Accounts) - 1)
			if kp.Type == KeypairTypeProfile {
				expectedLastUsedDerivationIndex-- // subtract one more in case of profile keypair because of chat account
			}

			// save keypair
			err = db.SaveOrUpdateKeypair(kp)
			require.NoError(t, err)
			dbKeypairs, err = db.GetActiveKeypairs()
			require.NoError(t, err)
			require.Equal(t, 1, len(dbKeypairs))
			dbKp, err := db.GetKeypairByKeyUID(kp.KeyUID)
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts), len(dbKp.Accounts))
			kp.LastUsedDerivationIndex = expectedLastUsedDerivationIndex
			require.Equal(t, kp.KeyUID, dbKp.KeyUID)
			dbAccounts, err = db.GetActiveAccounts()
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts), len(dbAccounts))

			// delete keypair
			err = db.RemoveKeypair(kp.KeyUID, 0)
			require.NoError(t, err)
			_, err = db.GetKeypairByKeyUID(kp.KeyUID)
			require.Error(t, err)
			require.True(t, err == ErrDbKeypairNotFound)

			// save keypair again to test the flow below
			err = db.SaveOrUpdateKeypair(kp)
			require.NoError(t, err)
			dbKeypairs, err = db.GetActiveKeypairs()
			require.NoError(t, err)
			require.Equal(t, 1, len(dbKeypairs))

			ind := len(kp.Accounts) - 1
			accToUpdate := kp.Accounts[ind]

			// try to save the same account again
			err = db.SaveOrUpdateAccounts([]*Account{accToUpdate}, false)
			require.NoError(t, err)
			dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts), len(dbKp.Accounts))
			require.Equal(t, kp.KeyUID, dbKp.KeyUID)
			dbAccounts, err = db.GetActiveAccounts()
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts), len(dbAccounts))

			// update an existing account
			accToUpdate.Name = accToUpdate.Name + "updated"
			accToUpdate.ColorID = common.CustomizationColorBrown
			accToUpdate.Emoji = accToUpdate.Emoji + "updated"

			err = db.SaveOrUpdateAccounts([]*Account{accToUpdate}, false)
			require.NoError(t, err)
			dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts), len(dbKp.Accounts))
			dbAccounts, err = db.GetActiveAccounts()
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts), len(dbAccounts))
			dbAcc, err := db.GetAccountByAddress(accToUpdate.Address)
			require.NoError(t, err)
			require.Equal(t, accToUpdate.Address, dbAcc.Address)

			// update keypair name
			kpToUpdate := kp
			kpToUpdate.Name = kpToUpdate.Name + "updated"
			err = db.SaveOrUpdateKeypair(kp)
			require.NoError(t, err)
			dbKeypairs, err = db.GetActiveKeypairs()
			require.NoError(t, err)
			require.Equal(t, 1, len(dbKeypairs))
			dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts), len(dbKp.Accounts))
			require.Equal(t, kpToUpdate.KeyUID, dbKp.KeyUID)

			// save new account to an existing keypair which is out of the default Status' derivation root path
			accToAdd := kp.Accounts[ind]
			accToAdd.Address = types.Address{0x08}
			accToAdd.Path = "m/44'/60'/0'/0/10"
			accToAdd.PublicKey = types.Hex2Bytes("0x000000008")
			accToAdd.Name = "Generated Acc 8"

			err = db.SaveOrUpdateAccounts([]*Account{accToAdd}, false)
			require.NoError(t, err)
			dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts)+1, len(dbKp.Accounts))
			require.Equal(t, kp.LastUsedDerivationIndex, dbKp.LastUsedDerivationIndex)
			dbAccounts, err = db.GetActiveAccounts()
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts)+1, len(dbAccounts))
			dbAcc, err = db.GetAccountByAddress(accToUpdate.Address)
			require.NoError(t, err)
			require.Equal(t, accToAdd.Address, dbAcc.Address)

			// save new account to an existing keypair which follows Status' default derivation root path
			accToAdd = kp.Accounts[ind]
			accToAdd.Address = types.Address{0x09}
			accToAdd.Path = "m/44'/60'/0'/0/3"
			accToAdd.PublicKey = types.Hex2Bytes("0x000000009")
			accToAdd.Name = "Generated Acc 9"

			expectedLastUsedDerivationIndex = 3
			if kp.Type == KeypairTypeSeed {
				accToAdd.Path = "m/44'/60'/0'/0/2"
				expectedLastUsedDerivationIndex = 2
			} else if kp.Type == KeypairTypeKey {
				accToAdd.Path = "m/44'/60'/0'/0/1"
				expectedLastUsedDerivationIndex = 1
			}

			err = db.SaveOrUpdateAccounts([]*Account{accToAdd}, false)
			require.NoError(t, err)
			dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts)+2, len(dbKp.Accounts))
			require.Equal(t, expectedLastUsedDerivationIndex, dbKp.LastUsedDerivationIndex)
			dbAccounts, err = db.GetActiveAccounts()
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts)+2, len(dbAccounts))
			dbAcc, err = db.GetAccountByAddress(accToUpdate.Address)
			require.NoError(t, err)
			require.Equal(t, accToAdd.Address, dbAcc.Address)

			// delete account
			err = db.RemoveAccount(accToAdd.Address, 0)
			require.NoError(t, err)
			dbAccounts, err = db.GetActiveAccounts()
			require.NoError(t, err)
			require.Equal(t, len(kp.Accounts)+1, len(dbAccounts))
			_, err = db.GetAccountByAddress(accToAdd.Address)
			require.Error(t, err)
			require.True(t, err == ErrDbAccountNotFound)

			for _, acc := range dbAccounts {
				err = db.RemoveAccount(acc.Address, 0)
				require.NoError(t, err)
			}

			_, err = db.GetKeypairByKeyUID(kp.KeyUID)
			require.Error(t, err)
			require.True(t, err == ErrDbKeypairNotFound)
		})
	}
}

func TestResolvingSuggestedDerivationPath(t *testing.T) {
	kp := GetProfileKeypairForTest(true, true, true)
	totalNumOfAccounts := len(kp.Accounts)

	db, stop := setupTestDB(t)
	defer stop()

	// check the db
	dbKp, err := db.GetKeypairByKeyUID(kp.KeyUID)
	require.Error(t, err)
	require.True(t, err == ErrDbKeypairNotFound)
	require.Nil(t, dbKp)

	expectedLastUsedDerivationIndex := uint64(2)

	// save keypair
	err = db.SaveOrUpdateKeypair(kp)
	require.NoError(t, err)
	dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, totalNumOfAccounts, len(dbKp.Accounts))
	require.Equal(t, expectedLastUsedDerivationIndex, dbKp.LastUsedDerivationIndex)

	// check number of addresses to generate
	numOfAddresses, err := db.GetNumOfAddressesToGenerateForKeypair(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, maxNumOfGeneratedAddresses, numOfAddresses)

	// check suggested path
	suggestedPath, err := db.ResolveSuggestedPathForKeypair(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, fmt.Sprintf("%s%d", statusWalletRootPath, expectedLastUsedDerivationIndex+1), suggestedPath)

	// prepare new account with the next suggested path
	generatedWalletAccountThatWillBeRemovedLater := &Account{
		Address:               types.Address{0x05},
		KeyUID:                kp.KeyUID,
		Wallet:                false,
		Chat:                  false,
		Type:                  AccountTypeGenerated,
		Path:                  suggestedPath,
		PublicKey:             types.Hex2Bytes("0x000000005"),
		Name:                  "Generated Acc 4",
		Emoji:                 "emoji-4",
		ColorID:               common.CustomizationColorPrimary,
		Hidden:                false,
		Clock:                 0,
		Removed:               false,
		Operable:              AccountFullyOperable,
		ProdPreferredChainIDs: "1",
		TestPreferredChainIDs: "5",
	}

	// add new account with the next suggested path
	err = db.SaveOrUpdateAccounts([]*Account{generatedWalletAccountThatWillBeRemovedLater}, false)
	require.NoError(t, err)

	totalNumOfAccounts++
	expectedLastUsedDerivationIndex++

	dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, totalNumOfAccounts, len(dbKp.Accounts))
	require.Equal(t, expectedLastUsedDerivationIndex, dbKp.LastUsedDerivationIndex)

	// check suggested path
	suggestedPath, err = db.ResolveSuggestedPathForKeypair(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, fmt.Sprintf("%s%d", statusWalletRootPath, expectedLastUsedDerivationIndex+1), suggestedPath)

	customSuggestedPath := fmt.Sprintf("%s%d", statusWalletRootPath, expectedLastUsedDerivationIndex+1+1)

	// prepare new account with the custom suggested path
	generatedWalletAccount := &Account{
		Address:               types.Address{0x07},
		KeyUID:                kp.KeyUID,
		Wallet:                false,
		Chat:                  false,
		Type:                  AccountTypeGenerated,
		Path:                  customSuggestedPath,
		PublicKey:             types.Hex2Bytes("0x000000007"),
		Name:                  "Generated Acc 6",
		Emoji:                 "emoji-6",
		ColorID:               common.CustomizationColorPrimary,
		Hidden:                false,
		Clock:                 0,
		Removed:               false,
		Operable:              AccountFullyOperable,
		ProdPreferredChainIDs: "1",
		TestPreferredChainIDs: "5",
	}

	// add new account with the next suggested path
	err = db.SaveOrUpdateAccounts([]*Account{generatedWalletAccount}, false)
	require.NoError(t, err)

	totalNumOfAccounts++

	dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, totalNumOfAccounts, len(dbKp.Accounts))
	require.Equal(t, expectedLastUsedDerivationIndex, dbKp.LastUsedDerivationIndex)

	// check suggested path
	suggestedPath, err = db.ResolveSuggestedPathForKeypair(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, fmt.Sprintf("%s%d", statusWalletRootPath, expectedLastUsedDerivationIndex+1), suggestedPath)

	// prepare new account with the next suggested path
	generatedWalletAccount = &Account{
		Address:               types.Address{0x06},
		KeyUID:                kp.KeyUID,
		Wallet:                false,
		Chat:                  false,
		Type:                  AccountTypeGenerated,
		Path:                  suggestedPath,
		PublicKey:             types.Hex2Bytes("0x000000006"),
		Name:                  "Generated Acc 5",
		Emoji:                 "emoji-5",
		ColorID:               common.CustomizationColorPrimary,
		Hidden:                false,
		Clock:                 0,
		Removed:               false,
		Operable:              AccountFullyOperable,
		ProdPreferredChainIDs: "1",
		TestPreferredChainIDs: "5",
	}

	// add new account with the next suggested path
	err = db.SaveOrUpdateAccounts([]*Account{generatedWalletAccount}, false)
	require.NoError(t, err)

	totalNumOfAccounts++
	expectedLastUsedDerivationIndex++

	dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, totalNumOfAccounts, len(dbKp.Accounts))
	require.Equal(t, expectedLastUsedDerivationIndex, dbKp.LastUsedDerivationIndex)

	// check suggested path
	suggestedPath, err = db.ResolveSuggestedPathForKeypair(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, fmt.Sprintf("%s%d", statusWalletRootPath, expectedLastUsedDerivationIndex+2), suggestedPath)

	// prepare new account with the next suggested path
	generatedWalletAccount = &Account{
		Address:               types.Address{0x08},
		KeyUID:                kp.KeyUID,
		Wallet:                false,
		Chat:                  false,
		Type:                  AccountTypeGenerated,
		Path:                  suggestedPath,
		PublicKey:             types.Hex2Bytes("0x000000008"),
		Name:                  "Generated Acc 7",
		Emoji:                 "emoji-7",
		ColorID:               common.CustomizationColorPrimary,
		Hidden:                false,
		Clock:                 0,
		Removed:               false,
		Operable:              AccountFullyOperable,
		ProdPreferredChainIDs: "1",
		TestPreferredChainIDs: "5",
	}

	// add new account with the next suggested path
	err = db.SaveOrUpdateAccounts([]*Account{generatedWalletAccount}, false)
	require.NoError(t, err)

	totalNumOfAccounts++
	expectedLastUsedDerivationIndex += 2

	dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, totalNumOfAccounts, len(dbKp.Accounts))
	require.Equal(t, expectedLastUsedDerivationIndex, dbKp.LastUsedDerivationIndex)

	// check suggested path
	suggestedPath, err = db.ResolveSuggestedPathForKeypair(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, fmt.Sprintf("%s%d", statusWalletRootPath, expectedLastUsedDerivationIndex+1), suggestedPath)

	// remove account
	err = db.RemoveAccount(generatedWalletAccountThatWillBeRemovedLater.Address, 0)
	require.NoError(t, err)

	totalNumOfAccounts--

	dbKp, err = db.GetKeypairByKeyUID(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, totalNumOfAccounts, len(dbKp.Accounts))
	require.Equal(t, expectedLastUsedDerivationIndex, dbKp.LastUsedDerivationIndex)

	_, err = db.GetAccountByAddress(generatedWalletAccountThatWillBeRemovedLater.Address)
	require.Error(t, err)
	require.True(t, err == ErrDbAccountNotFound)

	// check suggested path after removing account
	suggestedPath, err = db.ResolveSuggestedPathForKeypair(kp.KeyUID)
	require.NoError(t, err)
	require.Equal(t, fmt.Sprintf("%s%d", statusWalletRootPath, expectedLastUsedDerivationIndex+1), suggestedPath)
}