Merge keychains

src/core/keychain/KeychainManager.test.ts

@@ -62,7 +62,7 @@ test('[keychain/KeychainManager] :: should be able to export the seed phrase for
 
 test('[keychain/KeychainManager] :: should be able to add a read only wallet using an address', async () => {
  await keychainManager.importKeychain({
- type: 'ReadOnlyKeychain',
+ type: KeychainType.ReadOnlyKeychain,
  address: '0x70c16D2dB6B00683b29602CBAB72CE0Dcbc243C4',
  });
  const accounts = await keychainManager.getAccounts();
@@ -79,7 +79,10 @@ test('[keychain/KeychainManager] :: should be able to remove an account from a R
 });
 
 test('[keychain/KeychainManager] :: should be able to import a wallet using a private key', async () => {
- await keychainManager.importKeychain({ type: 'KeyPairKeychain', privateKey });
+ await keychainManager.importKeychain({
+ type: KeychainType.KeyPairKeychain,
+ privateKey,
+ });
  const accounts = await keychainManager.getAccounts();
  expect(accounts.length).toBe(2);
  expect(isAddress(accounts[1])).toBe(true);

src/core/keychain/KeychainManager.ts

@@ -101,28 +101,24 @@ class KeychainManager {
  this.state.initialized = true;
  }
  },
- deriveAccounts: async (
- opts: SerializedKeypairKeychain | SerializedHdKeychain,
- ): Promise<Address[]> => {
+ deriveAccounts: async (opts: SerializedKeychain): Promise<Address[]> => {
  let keychain;
  switch (opts.type) {
  case KeychainType.HdKeychain:
  keychain = new HdKeychain();
- await keychain.init(opts as SerializedHdKeychain);
+ await keychain.init(opts);
  break;
  case KeychainType.KeyPairKeychain:
  keychain = new KeyPairKeychain();
- await keychain.init(opts as SerializedKeypairKeychain);
+ await keychain.init(opts);
  break;
  case KeychainType.ReadOnlyKeychain:
  keychain = new ReadOnlyKeychain();
- await keychain.init(opts as unknown as SerializedReadOnlyKeychain);
+ await keychain.init(opts);
  break;
  case KeychainType.HardwareWalletKeychain:
  keychain = new HardwareWalletKeychain();
- await keychain.init(
- opts as unknown as SerializedHardwareWalletKeychain,
- );
+ await keychain.init(opts);
  break;
  default:
  throw new Error('Keychain type not recognized.');
@@ -134,24 +130,24 @@ class KeychainManager {
  switch (opts.type) {
  case KeychainType.HdKeychain:
  keychain = new HdKeychain();
- await keychain.init(opts as SerializedHdKeychain);
+ await keychain.init(opts);
  break;
  case KeychainType.KeyPairKeychain:
  keychain = new KeyPairKeychain();
- await keychain.init(opts as SerializedKeypairKeychain);
+ await keychain.init(opts);
  break;
  case KeychainType.ReadOnlyKeychain:
  keychain = new ReadOnlyKeychain();
- await keychain.init(opts as SerializedReadOnlyKeychain);
+ await keychain.init(opts);
  break;
  case KeychainType.HardwareWalletKeychain:
  keychain = new HardwareWalletKeychain();
- await keychain.init(opts as SerializedHardwareWalletKeychain);
+ await keychain.init(opts);
  break;
  default:
  throw new Error('Keychain type not recognized.');
  }
- await this.overrideReadOnlyKeychains(keychain);
+ await this.mergeKeychains(keychain);
  await this.checkForDuplicateInKeychain(keychain);
  this.state.keychains.push(keychain as Keychain);
  return keychain;
@@ -274,20 +270,27 @@ class KeychainManager {
  return false;
  }
 
- async overrideReadOnlyKeychains(incomingKeychain: Keychain) {
+ async mergeKeychains(incomingKeychain: Keychain) {
  if (incomingKeychain.type === KeychainType.ReadOnlyKeychain) return;
+
  const currentAccounts = await this.getAccounts();
  const incomingAccounts = await incomingKeychain.getAccounts();
  const conflictingAccounts = incomingAccounts.filter((acc) =>
  currentAccounts.includes(acc),
  );
- await Promise.all(
- conflictingAccounts.map(async (acc) => {
- const wallet = await this.getWallet(acc);
- const isReadOnly = wallet.type === KeychainType.ReadOnlyKeychain;
- if (isReadOnly) this.removeAccount(acc);
- }),
- );
+
+ for (const account of conflictingAccounts) {
+ const wallet = await this.getWallet(account);
+ // the incoming is not readOnly, so if the conflicting is, remove it to leave the one with higher privilages
+ // if the incoming is a hd wallet that derives an account in which the pk is already in the vault, remove this pk to leave the hd as the main
+ if (
+ wallet.type === KeychainType.ReadOnlyKeychain ||
+ (incomingKeychain.type === KeychainType.HdKeychain &&
+ wallet.type === KeychainType.KeyPairKeychain)
+ ) {
+ this.removeAccount(account);
+ }
+ }
  }
 
  async checkForDuplicateInKeychain(keychain: Keychain) {
@@ -330,13 +333,31 @@ class KeychainManager {
  return keychain;
  }
 
- async importKeychain(
- opts:
- | SerializedKeypairKeychain
- | SerializedHdKeychain
- | SerializedReadOnlyKeychain
- | SerializedHardwareWalletKeychain,
- ): Promise<Keychain> {
+ async removeKeychain(keychain: Keychain) {
+ this.state.keychains = this.state.keychains.filter((k) => k !== keychain);
+ }
+
+ async isMnemonicInVault(mnemonic: string) {
+ for (const k of this.state.keychains) {
+ if (k.type != KeychainType.HdKeychain) continue;
+ if ((await k.exportKeychain()) == mnemonic) return true;
+ }
+ return false;
+ }
+
+ async importKeychain(opts: SerializedKeychain): Promise<Keychain> {
+ if (opts.type === KeychainType.KeyPairKeychain) {
+ const newAccount = (await this.deriveAccounts(opts))[0];
+ const existingAccounts = await this.getAccounts();
+ if (existingAccounts.includes(newAccount)) {
+ const existingKeychain = await this.getKeychain(newAccount);
+ // if the account is already in the vault (like in a hd keychain), we don't want to import it again
+ // UNLESS it's a readOnlyKeychain, which we DO WANT to override it, importing the pk
+ if (existingKeychain.type != KeychainType.ReadOnlyKeychain)
+ return existingKeychain;
+ }
+ }
+
  const result = await privates.get(this).restoreKeychain({
  ...opts,
  imported: true,
@@ -522,13 +543,6 @@ class KeychainManager {
  throw new Error('No keychain found for account');
  }
 
- isAccountInReadOnlyKeychain(address: Address): Keychain | undefined {
- for (const keychain of this.state.keychains) {
- if (keychain.type !== KeychainType.ReadOnlyKeychain) continue;
- if ((keychain as ReadOnlyKeychain).address === address) return keychain;
- }
- }
-
  async getSigner(address: Address) {
  const keychain = await this.getKeychain(address);
  return keychain.getSigner(address);

src/core/keychain/index.ts

@@ -31,6 +31,7 @@ import {
 import { addHexPrefix } from '../utils/hex';
 
 import { keychainManager } from './KeychainManager';
+import { SerializedKeypairKeychain } from './keychainTypes/keyPairKeychain';
 
 interface TypedDataTypes {
  EIP712Domain: MessageTypeProperty[];
@@ -99,6 +100,10 @@ export const createWallet = async (): Promise<Address> => {
  return accounts[0];
 };
 
+export const isMnemonicInVault = async (mnemonic: EthereumWalletSeed) => {
+ return keychainManager.isMnemonicInVault(mnemonic);
+};
+
 export const deriveAccountsFromSecret = async (
  secret: EthereumWalletSeed,
 ): Promise<Address[]> => {
@@ -168,12 +173,16 @@ export const importWallet = async (
  return address;
  }
  case EthereumWalletType.privateKey: {
- const keychain = await keychainManager.importKeychain({
+ const opts: SerializedKeypairKeychain = {
  type: KeychainType.KeyPairKeychain,
  privateKey: secret,
- });
- const address = (await keychain.getAccounts())[0];
- return address;
+ };
+ const newAccount = (await keychainManager.deriveAccounts(opts))[0];
+
+ await keychainManager.importKeychain(opts);
+ // returning the derived address instead of the first from the keychain,
+ // because this pk could have been elevated to hd while importing
+ return newAccount;
  }
  case EthereumWalletType.readOnly: {
  const keychain = await keychainManager.importKeychain({

src/core/keychain/keychainTypes/hardwareWalletKeychain.ts

@@ -15,7 +15,7 @@ export interface SerializedHardwareWalletKeychain {
  hdPath?: string;
  deviceId?: string;
  accountsEnabled?: number;
- type: string;
+ type: KeychainType.HardwareWalletKeychain;
  autodiscover?: boolean;
  wallets?: Array<{ address: Address; index: number; hdPath?: string }>;
  accountsDeleted?: Array<number>;
@@ -24,11 +24,11 @@ export interface SerializedHardwareWalletKeychain {
 const privates = new WeakMap();
 
 export class HardwareWalletKeychain implements IKeychain {
- type: string;
+ type: KeychainType.HardwareWalletKeychain =
+ KeychainType.HardwareWalletKeychain;
  vendor?: string;
 
  constructor() {
- this.type = KeychainType.HardwareWalletKeychain;
  this.vendor = undefined;
 
  privates.set(this, {

src/core/keychain/keychainTypes/hdKeychain.ts

@@ -26,7 +26,7 @@ export interface SerializedHdKeychain {
  mnemonic: string;
  hdPath?: SupportedHDPath;
  accountsEnabled?: number;
- type: string;
+ type: KeychainType.HdKeychain;
  imported?: boolean;
  autodiscover?: boolean;
  accountsDeleted?: Array<number>;
@@ -47,11 +47,10 @@ const privates = new WeakMap<
 >();
 
 export class HdKeychain implements IKeychain {
- type: string;
+ type: KeychainType.HdKeychain = KeychainType.HdKeychain;
  imported: boolean;
 
  constructor() {
- this.type = KeychainType.HdKeychain;
  this.imported = false;
 
  privates.set(this, {
@@ -86,10 +85,19 @@ export class HdKeychain implements IKeychain {
  const _privates = privates.get(this)!;
  const derivedWallet = _privates.deriveWallet(index);
 
- // if account already exists in a readonly keychain, remove it
- keychainManager
- .isAccountInReadOnlyKeychain(derivedWallet.address)
- ?.removeAccount(derivedWallet.address);
+ // if account already exists in a another keychain, remove it
+ keychainManager.state.keychains.forEach(async (keychain) => {
+ const keychainAccounts = await keychain.getAccounts();
+ if (keychainAccounts.includes(derivedWallet.address)) {
+ keychain.removeAccount(derivedWallet.address);
+ if (
+ keychain.type == KeychainType.ReadOnlyKeychain ||
+ keychain.type == KeychainType.KeyPairKeychain
+ ) {
+ keychainManager.removeKeychain(keychain);
+ }
+ }
+ });
 
  const wallet = new Wallet(
  derivedWallet.privateKey as BytesLike,

src/core/keychain/keychainTypes/keyPairKeychain.ts

@@ -11,17 +11,16 @@ import { IKeychain, PrivateKey, TWallet } from '../IKeychain';
 import { RainbowSigner } from '../RainbowSigner';
 
 export interface SerializedKeypairKeychain {
- type: string;
+ type: KeychainType.KeyPairKeychain;
  privateKey: PrivateKey;
 }
 
 const privates = new WeakMap();
 
 export class KeyPairKeychain implements IKeychain {
- type: string;
+ type: KeychainType.KeyPairKeychain = KeychainType.KeyPairKeychain;
 
  constructor() {
- this.type = KeychainType.KeyPairKeychain;
  privates.set(this, {
  wallets: [],
  });

src/core/keychain/keychainTypes/readOnlyKeychain.ts

@@ -11,17 +11,13 @@ import { logger } from '~/logger';
 import { IKeychain, PrivateKey } from '../IKeychain';
 
 export interface SerializedReadOnlyKeychain {
- type: string;
+ type: KeychainType.ReadOnlyKeychain;
  address: Address;
 }
 export class ReadOnlyKeychain implements IKeychain {
- type: string;
+ type: KeychainType.ReadOnlyKeychain = KeychainType.ReadOnlyKeychain;
  address?: Address;
 
- constructor() {
- this.type = KeychainType.ReadOnlyKeychain;
- }
-
  init(options: SerializedReadOnlyKeychain) {
  this.deserialize(options);
  }

src/core/types/walletActions.ts

@@ -7,6 +7,7 @@ export enum walletActions {
  unlock = 'unlock',
  verify_password = 'verify_password',
  derive_accounts_from_secret = 'derive_accounts_from_secret',
+ is_mnemonic_in_vault = 'is_mnemonic_in_vault',
  create = 'create',
  import = 'import',
  add = 'add',

src/entries/background/handlers/handleWallets.ts

@@ -24,6 +24,7 @@ import {
  importHardwareWallet,
  importWallet,
  isInitialized,
+ isMnemonicInVault,
  isPasswordSet,
  isVaultUnlocked,
  lockVault,
@@ -151,6 +152,9 @@ export const handleWallets = () =>
  payload as EthereumWalletSeed,
  );
  break;
+ case 'is_mnemonic_in_vault':
+ response = await isMnemonicInVault(payload as EthereumWalletSeed);
+ break;
  case 'get_accounts':
  response = await getAccounts();
  break;