Update ledger module to new format

Author: lnbc1QWFyb24

src/modules/select/wallets/ledger.ts

@@ -7,12 +7,17 @@ import {
 import ledgerIcon from '../wallet-icons/icon-ledger'
 
 import createProvider from './providerEngine'
+import { generateAddresses, isValidPath } from './hd-wallet'
 
 import TransportU2F from '@ledgerhq/hw-transport-u2f'
 import Eth from '@ledgerhq/hw-app-eth'
 import * as EthereumTx from 'ethereumjs-tx'
 
 import buffer from 'buffer'
+import { getAddress } from '../../../utilities'
+
+const LEDGER_LIVE_PATH = `m/44'/60'`
+const ACCOUNTS_TO_GET = 5
 
 function ledger(options: LedgerOptions & CommonWalletOptions): WalletModule {
   const { rpcUrl, networkId, preferred, label, iconSrc, svg } = options
@@ -36,7 +41,7 @@ function ledger(options: LedgerOptions & CommonWalletOptions): WalletModule {
         interface: {
           name: 'Ledger',
           connect: provider.enable,
-          disconnect: () => provider.stop(),
+          disconnect: provider.disconnect,
           address: {
             get: async () => provider.getPrimaryAddress()
           },
@@ -65,10 +70,15 @@ async function ledgerProvider(options: {
   networkName: (id: number) => string
 }) {
   const { networkId, rpcUrl, BigNumber, networkName } = options
-  const basePath = networkIdToDerivationPath(networkId)
 
+  let dPath = ''
   let addressToPath = new Map()
   let enabled: boolean = false
+  let customPath = false
+
+  let account:
+    | undefined
+    | { publicKey: string; chainCode: string; path: string }
 
   const provider = createProvider({
     getAccounts: (callback: any) => {
@@ -84,37 +94,66 @@ async function ledgerProvider(options: {
     rpcUrl
   })
 
-  provider.getPrimaryAddress = getPrimaryAddress
-  provider.getAllAccountsAndBalances = getAllAccountsAndBalances
+  provider.setPath = setPath
+  provider.dPath = dPath
   provider.enable = enable
   provider.setPrimaryAccount = setPrimaryAccount
+  provider.getPrimaryAddress = getPrimaryAddress
+  provider.getAccounts = getAccounts
+  provider.getMoreAccounts = getMoreAccounts
   provider.getBalance = getBalance
+  provider.getBalances = getBalances
   provider.send = provider.sendAsync
+  provider.disconnect = disconnect
+  provider.isCustomPath = isCustomPath
 
-  function enable() {
-    enabled = true
-    return getAccounts(1)
+  let transport
+  let eth: any
+
+  try {
+    transport = await TransportU2F.create()
+    eth = new Eth(transport)
+  } catch (error) {
+    throw new Error('Error connecting to Ledger wallet')
   }
 
-  function addresses() {
-    return Array.from(addressToPath.keys())
+  function disconnect() {
+    console.log('resetting')
+    dPath = ''
+    addressToPath = new Map()
+    enabled = false
+    provider.stop()
   }
 
-  function getPrimaryAddress() {
-    return enabled ? addresses()[0] : undefined
+  async function setPath(path: string, custom?: boolean) {
+    if (custom) {
+      if (!isValidPath(path)) {
+        return false
+      }
+
+      const address = await getAddress(path)
+      addressToPath.set(address, path)
+      customPath = true
+      return true
+    }
+
+    customPath = false
+    dPath = path
+
+    return true
   }
 
-  async function getAllAccountsAndBalances(amountToGet: number = 5) {
-    const accounts = await getAccounts(amountToGet, true)
-    return Promise.all(
-      accounts.map(
-        (address: string) =>
-          new Promise(async resolve => {
-            const balance = await getBalance(address)
-            resolve({ address, balance })
-          })
-      )
-    )
+  function isCustomPath() {
+    return customPath
+  }
+
+  function enable() {
+    enabled = true
+    return getAccounts()
+  }
+
+  function addresses() {
+    return Array.from(addressToPath.keys())
   }
 
   function setPrimaryAccount(address: string) {
@@ -129,65 +168,98 @@ async function ledgerProvider(options: {
     addressToPath = new Map(accounts)
   }
 
-  function getAccounts(
-    numberToGet: number = 1,
-    getMore?: boolean
-  ): Promise<any[]> {
-    return new Promise(async (resolve, reject) => {
-      if (!enabled) {
-        resolve([null])
-      }
+  async function getAddress(path: string) {
+    try {
+      const result = await eth.getAddress(path)
+      return result.address
+    } catch (error) {}
+  }
 
-      const addressesAlreadyFetched = addressToPath.size
+  async function getPublicKey(eth: any) {
+    if (!dPath) {
+      throw new Error('a derivation path is needed to get the public key')
+    }
+
+    try {
+      const result = await eth.getAddress(dPath, false, true)
+      const { publicKey, chainCode } = result
 
-      if (addressesAlreadyFetched > 0 && !getMore) {
-        return resolve(addresses())
+      account = {
+        publicKey,
+        chainCode,
+        path: dPath
       }
 
-      const paths = []
+      return account
+    } catch (error) {
+      throw new Error(
+        'There was a problem getting access to your Ledger accounts.'
+      )
+    }
+  }
 
-      if (numberToGet > 1) {
-        for (
-          let i = addressesAlreadyFetched;
-          i < numberToGet + addressesAlreadyFetched;
-          i++
-        ) {
-          const ledgerLive = `${basePath}/${i}'/0/0`
-          const legacy = `${basePath}/0'/${i}'`
+  function getPrimaryAddress() {
+    return enabled ? addresses()[0] : undefined
+  }
 
-          paths.push(ledgerLive, legacy)
-        }
-      } else {
-        paths.push(`${basePath}/0'/0`)
-      }
+  async function getMoreAccounts() {
+    const accounts = await getAccounts(true)
+    return accounts && getBalances(accounts)
+  }
+
+  async function getAccounts(getMore?: boolean) {
+    if (!enabled) {
+      return [undefined]
+    }
 
-      let transport
-      let eth
+    if (addressToPath.size > 0 && !getMore) {
+      return addresses()
+    }
 
-      try {
-        transport = await TransportU2F.create()
-        eth = new Eth(transport)
-      } catch (error) {
-        reject({ message: 'Error connecting to Ledger wallet' })
+    if (dPath === LEDGER_LIVE_PATH) {
+      const currentAccounts = addressToPath.size
+      const paths = []
+      for (
+        let i = currentAccounts;
+        i < ACCOUNTS_TO_GET + currentAccounts;
+        i++
+      ) {
+        paths.push(`${LEDGER_LIVE_PATH}/${i}'/0/0`)
       }
 
       for (const path of paths) {
         try {
-          const { address } = await eth.getAddress(path)
-          addressToPath.set(address.toLowerCase(), path)
-        } catch (err) {
-          return reject({
-            message: 'There was a problem trying to connect to your Ledger.'
-          })
+          const res = await eth.getAddress(path)
+          addressToPath.set(res.address, path)
+        } catch (error) {
+          console.log({ error })
         }
       }
+    } else {
+      const accountInfo = account || (await getPublicKey(eth))
 
-      const allAddresses = addresses()
+      if (!accountInfo) return [undefined]
 
-      transport.close()
+      const addressInfo = generateAddresses(accountInfo, addressToPath.size)
 
-      resolve(allAddresses)
-    })
+      addressInfo.forEach(({ dPath, address }) => {
+        addressToPath.set(address, dPath)
+      })
+    }
+
+    return addresses()
+  }
+
+  function getBalances(addresses: Array<string>) {
+    return Promise.all(
+      addresses.map(
+        address =>
+          new Promise(async resolve => {
+            const balance = await getBalance(address)
+            resolve({ address, balance })
+          })
+      )
+    )
   }
 
   function getBalance(address: string) {