Trezor implementation working

Author: lnbc1QWFyb24

src/modules/check/accounts.ts

@@ -14,12 +14,15 @@ function accountSelect(): WalletCheckModule {
   return async (
     stateAndHelpers: StateAndHelpers
   ): Promise<WalletCheckModal | undefined> => {
-    const { wallet, BigNumber, address, balance } = stateAndHelpers
+    const { wallet, BigNumber } = stateAndHelpers
     const { provider, type } = wallet
 
     if (type === 'hardware' && !completed) {
-      if (accountsAndBalances.length <= 1 && !loadingAccounts) {
-        accountsAndBalances = [{ address, balance }]
+      if (accountsAndBalances.length === 0) {
+        loadingAccounts = true
+        const accounts = await provider.getAccounts()
+        accountsAndBalances = await provider.getBalances(accounts)
+        loadingAccounts = false
       }
 
       const deleteWindowProperties = () => {
@@ -29,8 +32,7 @@ function accountSelect(): WalletCheckModule {
 
       const loadMoreAccounts = async () => {
         loadingAccounts = true
-        const moreAccounts = await provider.getAllAccountsAndBalances()
-        accountsAndBalances = moreAccounts
+        accountsAndBalances = await provider.getMoreAccounts()
         loadingAccounts = false
       }
 

src/modules/check/derivation-path.ts

@@ -23,12 +23,14 @@ const baseStyles = `
   background: inherit;
   font-size: 0.889em;
   font-family: inherit;
-  border: 1px solid #282828;
+  border-width: 1px;
+  border-style: solid;
+  border-color: inherit;
   border-radius: 40px;
   margin-top: 0.5rem;
   padding: 0.55em 1.4em;
   cursor: pointer;
-  color: #282828;
+  color: inherit;
   font-family: inherit;
   transition: background 150ms ease-in-out;
   line-height: 1.15;

src/modules/select/wallets/hd-wallet.ts

@@ -2,24 +2,29 @@ import HDKey from 'hdkey'
 import { publicToAddress, toChecksumAddress } from 'ethereumjs-util'
 import buffer from 'buffer'
 
+const numberToGet = 30
+
 export function generateAddresses(
-  publicKey: string,
-  chainCode: string,
-  basePath: string,
-  amount: number = 30
+  account: {
+    publicKey: string
+    chainCode: string
+    path: string
+  },
+  offset: number
 ) {
+  const { publicKey, chainCode, path } = account
   const hdk = new HDKey()
 
   hdk.publicKey = new buffer.Buffer(publicKey, 'hex')
   hdk.chainCode = new buffer.Buffer(chainCode, 'hex')
 
   const addresses = []
 
-  for (let i = 0; i < amount; i++) {
+  for (let i = offset; i < numberToGet + offset; i++) {
     const dkey = hdk.deriveChild(i)
     const address = publicToAddress(dkey.publicKey, true).toString('hex')
     addresses.push({
-      dPath: `${basePath}/${i}`,
+      dPath: `${path}/${i}`,
       address: toChecksumAddress(address)
     })
   }

src/modules/select/wallets/trezor.ts

@@ -56,8 +56,8 @@ function trezor(options: TrezorOptions & CommonWalletOptions): WalletModule {
           },
           balance: {
             get: async () => {
-              const address = provider.getPrimaryAddress()
-              return address && provider.getBalance(address)
+              const accounts = provider.getPrimaryAddress()
+              return accounts[0] && provider.getBalance(accounts[0])
             }
           }
         }
@@ -84,6 +84,10 @@ async function trezorProvider(options: {
   let addressToPath = new Map()
   let enabled: boolean = false
 
+  let account:
+    | undefined
+    | { publicKey: string; chainCode: string; path: string }
+
   TrezorConnect.manifest({
     email,
     appUrl
@@ -110,17 +114,18 @@ async function trezorProvider(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
 
   function setPath(path: string) {
-    console.log({ path })
     dPath = path
   }
 
@@ -133,23 +138,6 @@ async function trezorProvider(options: {
     return Array.from(addressToPath.keys())
   }
 
-  function getPrimaryAddress() {
-    return enabled ? addresses()[0] : undefined
-  }
-
-  async function getAllAccountsAndBalances() {
-    const accounts = await getAccounts()
-    return Promise.all(
-      accounts.map(
-        address =>
-          new Promise(async resolve => {
-            const balance = await getBalance(address)
-            resolve({ address, balance })
-          })
-      )
-    )
-  }
-
   function setPrimaryAccount(address: string) {
     // make a copy and put in an array
     const accounts = [...addressToPath.entries()]
@@ -162,25 +150,44 @@ async function trezorProvider(options: {
     addressToPath = new Map(accounts)
   }
 
-  async function getAccounts() {
+  async function getPublicKey() {
+    const result = await TrezorConnect.getPublicKey({
+      path: dPath,
+      coin: 'eth'
+    })
+
+    account = {
+      publicKey: result.payload.publicKey,
+      chainCode: result.payload.chainCode,
+      path: result.payload.serializedPath
+    }
+
+    return account
+  }
+
+  function getPrimaryAddress() {
+    return enabled ? addresses()[0] : undefined
+  }
+
+  async function getMoreAccounts() {
+    const accounts = await getAccounts(true)
+    return getBalances(accounts)
+  }
+
+  async function getAccounts(getMore?: boolean) {
     if (!enabled) {
       return [undefined]
     }
 
-    if (addressToPath.size > 0) {
+    if (addressToPath.size > 0 && !getMore) {
       return addresses()
     }
 
-    const trezorAccount = await TrezorConnect.getPublicKey({
-      path: dPath,
-      coin: 'eth'
-    })
+    const accountInfo = account || (await getPublicKey())
 
-    const addressInfo = generateAddresses(
-      trezorAccount.payload.publicKey,
-      trezorAccount.payload.chainCode,
-      trezorAccount.payload.serializedPath
-    )
+    const addressInfo = generateAddresses(accountInfo, addressToPath.size)
+
+    console.log({ addressInfo })
 
     addressInfo.forEach(({ dPath, address }) => {
       addressToPath.set(address, dPath)
@@ -189,6 +196,18 @@ async function trezorProvider(options: {
     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) {
     return new Promise((resolve, reject) => {
       provider.sendAsync(
@@ -253,11 +272,4 @@ async function trezorProvider(options: {
   return provider
 }
 
-function networkIdToDerivationPath(networkId: number) {
-  switch (networkId) {
-    default:
-      return `m/44'/60'`
-  }
-}
-
 export default trezor