wallet-stack 1.0.0-alpha.121

package/src/web3/KeychainAccounts.ts

@@ -0,0 +1,309 @@
+import { ErrorMessages } from 'src/app/ErrorMessages'
+import { generateKeysFromMnemonic, getStoredMnemonic } from 'src/backup/utils'
+import {
+  listStoredItems,
+  removeStoredItem,
+  retrieveStoredItem,
+  storeItem,
+} from 'src/storage/keychain'
+import Logger from 'src/utils/Logger'
+import {
+  isValidAddress,
+  normalizeAddress,
+  normalizeAddressWith0x,
+  privateKeyToAddress,
+} from 'src/utils/address'
+import { aesDecrypt, aesEncrypt } from 'src/utils/aes'
+import { ViemKeychainAccount, keychainAccountToAccount } from 'src/viem/keychainAccountToAccount'
+import { type Hex } from 'viem'
+import { type Address } from 'viem/accounts'
+
+const TAG = 'web3/KeychainAccounts'
+
+export const ACCOUNT_STORAGE_KEY_PREFIX = 'account--'
+
+interface KeychainAccount {
+  address: string
+  createdAt: Date
+  importFromMnemonic?: boolean
+}
+
+interface ImportMnemonicAccount {
+  address: string | null
+  createdAt: Date
+}
+
+// Produces a storage key that looks like this: "account--2022-05-24T13:55:47.117Z--2d936b3ada6142b4248de1847c14fa2f4c5b63c3"
+function accountStorageKey(account: KeychainAccount) {
+  if (!isValidAddress(account.address)) {
+    throw new Error('Expecting valid address for computing storage key')
+  }
+  return `${ACCOUNT_STORAGE_KEY_PREFIX}${account.createdAt.toISOString()}--${normalizeAddress(
+    account.address
+  )}`
+}
+
+export async function encryptPrivateKey(privateKey: string, password: string) {
+  return aesEncrypt(privateKey, password)
+}
+
+export async function decryptPrivateKey(encryptedPrivateKey: string, password: string) {
+  try {
+    return aesDecrypt(encryptedPrivateKey, password)
+  } catch (e) {
+    // decrypt can sometimes throw if the inputs are incorrect (encryptedPrivateKey or password)
+    Logger.warn(TAG, 'Failed to decrypt private key', e)
+    return null
+  }
+}
+
+async function storePrivateKey(privateKey: string, account: KeychainAccount, password: string) {
+  const encryptedPrivateKey = await encryptPrivateKey(privateKey, password)
+  return storeItem({ key: accountStorageKey(account), value: encryptedPrivateKey })
+}
+
+// Note: ideally this wouldn't be exported, so we don't accidentally expose the private key
+// but it's needed for now to support the existing KeychainAccounts and the viem wallet
+export async function getStoredPrivateKey(
+  account: KeychainAccount,
+  password: string
+): Promise<string | null> {
+  Logger.debug(
+    `${TAG}@getStoredPrivateKey`,
+    `Checking keychain for private key for account`,
+    account
+  )
+  const encryptedPrivateKey = await retrieveStoredItem(accountStorageKey(account))
+  if (!encryptedPrivateKey) {
+    if (account.importFromMnemonic) {
+      Logger.info(
+        `${TAG}@getStoredPrivateKey`,
+        `Private key for existing account ${account.address} not found in keychain, importing from mnemonic now`
+      )
+      return await importAndStorePrivateKeyFromMnemonic(account, password)
+    }
+
+    throw new Error('No private key found in storage')
+  }
+
+  const privateKey = await decryptPrivateKey(encryptedPrivateKey, password)
+  if (!privateKey) {
+    return privateKey
+  }
+
+  // There was a bug introduced in https://github.com/valora-xyz/wallet/blob/f7b3a2cc7c2689a17b7eb50edfdb1b8743f441d1/src/web3/KeychainAccountManager.ts#L63-L71
+  // which caused the private key to be stored without the 0x prefix
+  // so all accounts created or imported after that change will have the private key stored without the 0x prefix
+  // Later on we reverted the code with the bug and it caused signing issues for these accounts.
+  // Here we make sure that we always return the private key with the 0x prefix
+  // Additionally, pad the private key to 64 characters to handle keys with leading zeros
+  // that may have been stored as 63 characters (or fewer)
+  const paddedKey = privateKey.replace(/^0x/, '').padStart(64, '0')
+  return normalizeAddressWith0x(paddedKey)
+}
+
+/**
+ * Returns accounts that have been stored in the keychain, sorted by creation date
+ * The ordering is important: Geth KeyStore did this and some parts of the code base rely on it.
+ * @param importMnemonicAccount ImportMnemonicAccount the existing account to import from the mnemonic, if not already present in the keychain
+ */
+export async function listStoredAccounts(importMnemonicAccount?: ImportMnemonicAccount) {
+  let accounts: KeychainAccount[]
+  try {
+    const storedItems = await listStoredItems()
+    Logger.info(`${TAG}@listStoredAccounts`, 'Keychain items:', storedItems)
+    accounts = storedItems
+      .filter((item) => item.startsWith(ACCOUNT_STORAGE_KEY_PREFIX))
+      .map((item) => {
+        const [isoDate, rawAddress] = item.slice(ACCOUNT_STORAGE_KEY_PREFIX.length).split('--')
+        const address = normalizeAddressWith0x(rawAddress)
+        const createdAt = new Date(isoDate)
+        return {
+          address,
+          createdAt,
+        }
+      })
+      .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime())
+
+    // Check if we need to migrate the existing Geth KeyStore based account into the keychain, by importing it from the mnemonic
+    if (importMnemonicAccount?.address) {
+      const normalizedMnemonicAccountAddress = normalizeAddressWith0x(importMnemonicAccount.address)
+      const account = accounts.find((a) => a.address === normalizedMnemonicAccountAddress)
+      if (!account) {
+        Logger.info(
+          `${TAG}@listStoredAccounts`,
+          `Existing account ${importMnemonicAccount.address} not found in the keychain, will import from the stored mnemonic on next unlock`
+        )
+        const now = Date.now()
+        // Ensure the imported account is always first in the list
+        const maxCreationTime = Math.min(
+          importMnemonicAccount.createdAt.getTime(),
+          (accounts[0]?.createdAt.getTime() ?? now) - 1,
+          now
+        )
+        const createdAt = new Date(maxCreationTime)
+        accounts = [
+          { address: normalizedMnemonicAccountAddress, createdAt, importFromMnemonic: true },
+          ...accounts,
+        ]
+      }
+    }
+  } catch (e) {
+    Logger.error(`${TAG}@listStoredAccounts`, 'Error listing accounts', e)
+    throw new Error(ErrorMessages.KEYCHAIN_FETCH_ACCOUNTS)
+  }
+  return accounts
+}
+
+async function importAndStorePrivateKeyFromMnemonic(account: KeychainAccount, password: string) {
+  const mnemonic = await getStoredMnemonic(account.address, password)
+  if (!mnemonic) {
+    throw new Error('No mnemonic found in storage')
+  }
+
+  const { privateKey } = await generateKeysFromMnemonic(mnemonic)
+  if (!privateKey) {
+    throw new Error('Failed to generate private key from mnemonic')
+  }
+
+  // Prefix 0x here or else the signed transaction produces dramatically different signer!!!
+  const normalizedPrivateKey = normalizeAddressWith0x(privateKey) as Address
+  const accountFromPrivateKey = normalizeAddressWith0x(privateKeyToAddress(normalizedPrivateKey))
+  if (accountFromPrivateKey !== account.address) {
+    throw new Error(
+      `Generated private key address (${accountFromPrivateKey}) does not match the existing account address (${account.address})`
+    )
+  }
+
+  await storePrivateKey(normalizedPrivateKey, account, password)
+
+  return normalizedPrivateKey
+}
+
+export async function clearStoredAccounts() {
+  Logger.info(`${TAG}@clearStoredAccounts`, 'Clearing all accounts from keychain')
+  const accounts = await listStoredAccounts()
+  await Promise.all(accounts.map((account) => removeStoredItem(accountStorageKey(account))))
+}
+
+export class KeychainAccounts {
+  protected loadedAccounts: Map<
+    string,
+    {
+      // Timestamp in milliseconds when the keychain was last unlocked
+      unlockTime?: number
+      // Number of seconds that the keychain was last unlocked for
+      unlockDuration?: number
+      account: KeychainAccount
+      viemAccount: ViemKeychainAccount
+    }
+  > = new Map()
+
+  async loadExistingAccounts(
+    importMnemonicAccount?: ImportMnemonicAccount
+  ): Promise<KeychainAccount[]> {
+    const accounts = await listStoredAccounts(importMnemonicAccount)
+
+    for (const account of accounts) {
+      this.addExistingAccount(account)
+    }
+    return accounts
+  }
+
+  async addAccount(privateKey: string, passphrase: string): Promise<KeychainAccount> {
+    Logger.info(`${TAG}@addAccount`, `Adding a new account`)
+    // Prefix 0x here or else the signed transaction produces dramatically different signer!!!
+    const normalizedPrivateKey = normalizeAddressWith0x(privateKey) as Address
+    const address = normalizeAddressWith0x(privateKeyToAddress(normalizedPrivateKey))
+    if (this.loadedAccounts.has(address)) {
+      throw new Error(ErrorMessages.KEYCHAIN_ACCOUNT_ALREADY_EXISTS)
+    }
+    const account = { address, createdAt: new Date() }
+    this.addExistingAccount(account)
+    await storePrivateKey(privateKey, account, passphrase)
+    return account
+  }
+
+  private addExistingAccount(account: KeychainAccount) {
+    const viemAccount = keychainAccountToAccount({
+      address: account.address as Address,
+      isUnlocked: () => this.isUnlocked(account.address),
+    })
+    this.loadedAccounts.set(normalizeAddressWith0x(account.address), { account, viemAccount })
+  }
+
+  // This mimics the behavior of the removed KeychainWallet
+  // Makes it easier for existing code to transition to this new class
+  // TODO: we should remove this and stop relying on the order of accounts
+  getAccounts(): string[] {
+    return Array.from(this.loadedAccounts.keys())
+  }
+
+  /**
+   * Unlocks an account for a given duration
+   * A duration of 0 means the account is unlocked indefinitely
+   * */
+  async unlock(address: string, passphrase: string, duration: number) {
+    const normalizedAddress = normalizeAddressWith0x(address)
+    Logger.debug(`${TAG}@unlock`, `Unlocking keychain for ${address} for ${duration} seconds`)
+    if (!this.loadedAccounts.has(normalizedAddress)) {
+      return false
+    }
+    const { account, viemAccount } = this.loadedAccounts.get(normalizedAddress)!
+    const privateKey = await getStoredPrivateKey(account, passphrase)
+    if (!privateKey) {
+      return false
+    }
+    this.loadedAccounts.set(normalizedAddress, {
+      account,
+      viemAccount,
+      unlockTime: Date.now(),
+      unlockDuration: duration,
+    })
+    viemAccount.unlock(privateKey as Hex)
+    return true
+  }
+
+  isUnlocked(address: string): boolean {
+    const normalizedAddress = normalizeAddressWith0x(address)
+    if (!this.loadedAccounts.has(normalizedAddress)) {
+      return false
+    }
+    const { unlockTime, unlockDuration } = this.loadedAccounts.get(normalizedAddress)!
+    if (unlockDuration === undefined || unlockTime === undefined) {
+      return false
+    }
+
+    // Unlock duration of 0 means the account is unlocked indefinitely
+    if (unlockDuration === 0) {
+      return true
+    }
+
+    return unlockTime + unlockDuration * 1000 > Date.now()
+  }
+
+  /**
+   * Updates the passphrase of an account
+   * @param oldPassphrase - the passphrase currently associated with the account
+   * @param newPassphrase - the new passphrase to use with the account
+   * @returns whether the update was successful
+   */
+  async updatePassphrase(address: string, oldPassphrase: string, newPassphrase: string) {
+    const normalizedAddress = normalizeAddressWith0x(address)
+    if (!this.loadedAccounts.has(normalizedAddress)) {
+      return false
+    }
+    const account = this.loadedAccounts.get(normalizedAddress)!.account
+    const privateKey = await getStoredPrivateKey(account, oldPassphrase)
+    if (!privateKey) {
+      return false
+    }
+    await storePrivateKey(privateKey, account, newPassphrase)
+    return true
+  }
+
+  getViemAccount(address: string): ViemKeychainAccount | undefined {
+    const normalizedAddress = normalizeAddressWith0x(address)
+    return this.loadedAccounts.get(normalizedAddress)?.viemAccount
+  }
+}

package/src/web3/actions.ts

@@ -0,0 +1,30 @@
+export enum Actions {
+  SET_ACCOUNT = 'WEB3/SET_ACCOUNT',
+  DEMO_MODE_TOGGLED = 'WEB3/DEMO_MODE_TOGGLED',
+}
+
+export interface SetAccountAction {
+  type: Actions.SET_ACCOUNT
+  address: string
+}
+
+interface DemoModeToggled {
+  type: Actions.DEMO_MODE_TOGGLED
+  enabled: boolean
+}
+
+export type ActionTypes = SetAccountAction | DemoModeToggled
+
+export const setAccount = (address: string): SetAccountAction => {
+  return {
+    type: Actions.SET_ACCOUNT,
+    address: address.toLowerCase(),
+  }
+}
+
+export const demoModeToggled = (enabled: boolean): DemoModeToggled => {
+  return {
+    type: Actions.DEMO_MODE_TOGGLED,
+    enabled,
+  }
+}

package/src/web3/consts.ts

@@ -0,0 +1,8 @@
+// Hard-coded values for the number of Wei, smallest divisible unit of currency, in CELO and cUSD
+// respectively. Because they are the same, a single constant is used.
+export const WEI_DECIMALS = 18
+
+// Whenever the user enters their PIN, leave the account unlocked for 10 minutes.
+export const UNLOCK_DURATION = 600
+
+export const ETHEREUM_DERIVATION_PATH = "m/44'/60'/0'"

package/src/web3/contracts.test.ts

@@ -0,0 +1,115 @@
+import { expectSaga } from 'redux-saga-test-plan'
+import { call, select } from 'redux-saga/effects'
+import { getPasswordSaga } from 'src/pincode/authentication'
+import getLockableViemWallet, { ViemWallet } from 'src/viem/getLockableWallet'
+import { getStoredPrivateKey, listStoredAccounts } from 'src/web3/KeychainAccounts'
+import { walletAddressSelector } from 'src/web3/selectors'
+import { celo } from 'viem/chains'
+import { getKeychainAccounts as getKeychainAccountsFn, getViemWallet } from './contracts'
+
+jest.unmock('src/web3/contracts')
+jest.mock('src/viem/getLockableWallet')
+
+let getKeychainAccounts: typeof getKeychainAccountsFn
+let loadExistingAccountsSpy: jest.SpyInstance
+
+beforeEach(() => {
+  jest.clearAllMocks()
+  // Isolate the module so its variables don't persist between tests
+  // Note: this slows down the tests a bit
+  jest.isolateModules(() => {
+    getKeychainAccounts = require('./contracts').getKeychainAccounts
+    loadExistingAccountsSpy = jest.spyOn(
+      require('src/web3/KeychainAccounts').KeychainAccounts.prototype,
+      'loadExistingAccounts'
+    )
+  })
+})
+
+describe('getKeychainAccounts', () => {
+  it('should initialize keychain accounts', async () => {
+    const keychainAccounts = await getKeychainAccounts()
+    expect(keychainAccounts).toBeDefined()
+    expect(loadExistingAccountsSpy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should only load existing accounts once', async () => {
+    const [a1, a2, a3] = await Promise.all([
+      getKeychainAccounts(),
+      getKeychainAccounts(),
+      getKeychainAccounts(),
+    ])
+    expect(loadExistingAccountsSpy).toHaveBeenCalledTimes(1)
+    expect(a1).toBe(a2)
+    expect(a2).toBe(a3)
+  })
+
+  it('should throw if knex fails to initialize', async () => {
+    loadExistingAccountsSpy.mockImplementationOnce(() => {
+      throw new Error('Test error')
+    })
+    await expect(getKeychainAccounts()).rejects.toThrow('Test error')
+  })
+
+  it('should keep failed initializations', async () => {
+    loadExistingAccountsSpy.mockImplementationOnce(() => {
+      throw new Error('Test error')
+    })
+    await expect(getKeychainAccounts()).rejects.toThrow('Test error')
+    await expect(getKeychainAccounts()).rejects.toThrow('Test error')
+    expect(loadExistingAccountsSpy).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('getViemWallet', () => {
+  it('throws if address not found', async () => {
+    return expect(
+      expectSaga(getViemWallet, celo)
+        .provide([[select(walletAddressSelector), null]])
+        .run()
+    ).rejects.toThrowError('Wallet address not found')
+  })
+  it('returns a lockable wallet', async () => {
+    const date = new Date()
+
+    jest.mocked(getLockableViemWallet).mockReturnValue('foo' as unknown as ViemWallet)
+    await expectSaga(getViemWallet, celo)
+      .provide([
+        [select(walletAddressSelector), '0x123'],
+        [call(listStoredAccounts), [{ address: '0x123', createdAt: date }]],
+        [call(getPasswordSaga, '0x123', true, false), 'password'],
+        [
+          call(getStoredPrivateKey, { address: '0x123', createdAt: new Date() }, 'password'),
+          'password',
+        ],
+      ])
+      .returns('foo')
+      .run()
+
+    expect(getLockableViemWallet).toHaveBeenCalledTimes(1)
+
+    // Verifying that the wallet is cached
+    await expectSaga(getViemWallet, celo).returns('foo').run()
+    expect(getLockableViemWallet).toHaveBeenCalledTimes(1)
+
+    // get a wallet with app transport and ensure it is not from the cache
+    await expectSaga(getViemWallet, celo, true)
+      .provide([
+        [select(walletAddressSelector), '0x123'],
+        [call(listStoredAccounts), [{ address: '0x123', createdAt: date }]],
+        [call(getPasswordSaga, '0x123', true, false), 'password'],
+        [
+          call(getStoredPrivateKey, { address: '0x123', createdAt: new Date() }, 'password'),
+          'password',
+        ],
+      ])
+      .returns('foo')
+      .run()
+
+    expect(getLockableViemWallet).toHaveBeenCalledTimes(2)
+
+    // Verifying that the app transport wallet is cached
+    await expectSaga(getViemWallet, celo, true).returns('foo').run()
+    expect(getLockableViemWallet).toHaveBeenCalledTimes(2)
+  })
+})

package/src/web3/contracts.ts

@@ -0,0 +1,74 @@
+/**
+ * This file is called 'contracts' but it's responsibilities have changed over time.
+ * It now manages keychain and wallet initialization.
+ * Leaving the name for recognizability to current devs
+ */
+import { accountCreationTimeSelector } from 'src/account/selectors'
+import { store } from 'src/redux/store'
+import Logger from 'src/utils/Logger'
+import getLockableViemWallet, { ViemWallet } from 'src/viem/getLockableWallet'
+import { KeychainAccounts } from 'src/web3/KeychainAccounts'
+import { walletAddressSelector } from 'src/web3/selectors'
+import { call, select } from 'typed-redux-saga'
+import { Address, Chain } from 'viem'
+
+const TAG = 'web3/contracts'
+
+const viemWallets = new Map<Chain, ViemWallet>()
+const appViemWallets = new Map<Chain, ViemWallet>()
+
+let initKeychainAccountsPromise: Promise<KeychainAccounts> | null = null
+
+// This should be called only via getKeychainAccounts
+// To ensure it's only called once
+async function initKeychainAccounts() {
+  Logger.info(`${TAG}@initKeychainAccounts`, `Initializing`)
+
+  const state = store.getState()
+  const walletAddress = walletAddressSelector(state)
+  const accountCreationTime = accountCreationTimeSelector(state)
+
+  // This is to migrate the existing account that used to be stored in the geth keystore
+  const importMnemonicAccount = {
+    address: walletAddress,
+    createdAt: new Date(accountCreationTime),
+  }
+  Logger.info(`${TAG}@initKeychainAccounts`, 'Initializing wallet', importMnemonicAccount)
+
+  const keychainAccounts = new KeychainAccounts()
+  const existingAccounts = await keychainAccounts.loadExistingAccounts(importMnemonicAccount)
+
+  Logger.info(`${TAG}@initKeychainAccounts`, `Initialized with accounts: ${existingAccounts}`)
+
+  return keychainAccounts
+}
+
+export function getKeychainAccounts(): Promise<KeychainAccounts> {
+  initKeychainAccountsPromise = initKeychainAccountsPromise || initKeychainAccounts()
+
+  return initKeychainAccountsPromise
+}
+
+export type GetViemWallet = typeof getViemWallet
+// This code assumes that the account for walletAddress already exists in the Keychain
+// which is a responsibility currently handled by KeychainAccounts
+export function* getViemWallet(chain: Chain, useAppTransport?: boolean) {
+  const walletsCache = useAppTransport ? appViemWallets : viemWallets
+  if (walletsCache.has(chain)) {
+    return walletsCache.get(chain) as ViemWallet
+  }
+  const walletAddress = yield* select(walletAddressSelector)
+  if (!walletAddress) {
+    throw new Error('Wallet address not found')
+  }
+  const keychainAccounts = yield* call(getKeychainAccounts)
+  const wallet = getLockableViemWallet(
+    keychainAccounts,
+    chain,
+    walletAddress as Address,
+    useAppTransport
+  )
+  Logger.debug(`${TAG}@getViemWallet`, `Initialized wallet with account: ${wallet.account}`)
+  walletsCache.set(chain, wallet)
+  return wallet
+}

package/src/web3/networkConfig.test.ts

@@ -0,0 +1,18 @@
+import {
+  walletConnectChainIdToNetwork,
+  walletConnectChainIdToNetworkId,
+} from 'src/web3/networkConfig'
+import { NetworkId, Network } from 'src/transactions/types'
+
+describe('networkConfig', () => {
+  it('walletConnectChainIdToNetworkId spot checks', () => {
+    // not attempting to check every value (too circular). just making sure inversion of networkIdToWalletConnectChainId is working as expected
+    expect(walletConnectChainIdToNetworkId['eip155:42220']).toEqual(NetworkId['celo-mainnet'])
+    expect(walletConnectChainIdToNetworkId['eip155:1']).toEqual(NetworkId['ethereum-mainnet'])
+  })
+  it('walletConnectChainIdToNetwork spot checks', () => {
+    // not checking every value (too circular), just testing the logic used to populate this object
+    expect(walletConnectChainIdToNetwork['eip155:42220']).toEqual(Network.Celo)
+    expect(walletConnectChainIdToNetwork['eip155:1']).toEqual(Network.Ethereum)
+  })
+})