Merge pull request #647 from blocknative/release/1.33.0

Release: 1.33.0 - Master

Author: taylorjdawson

.prettierrc.js

@@ -5,6 +5,5 @@ module.exports = {
   printWidth: 80,
   tabWidth: 2,
   arrowParens: 'avoid',
-  svelteSortOrder: 'options-scripts-styles-markup',
-  plugins: ['prettier-plugin-svelte']
+  svelteSortOrder: 'options-scripts-styles-markup'
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "bnc-onboard",
-  "version": "1.32.0",
+  "version": "1.33.0",
   "description": "Onboard users to web3 by allowing them to select a wallet, get that wallet ready to transact and have access to synced wallet state.",
   "keywords": [
     "ethereum",
@@ -59,6 +59,7 @@
     "@ethereumjs/tx": "^3.0.0",
     "@gnosis.pm/safe-apps-provider": "^0.5.0",
     "@gnosis.pm/safe-apps-sdk": "^3.0.0",
+    "@keystonehq/eth-keyring": "0.7.2",
     "@ledgerhq/hw-app-eth": "^5.49.0",
     "@ledgerhq/hw-transport-u2f": "^5.21.0",
     "@ledgerhq/hw-transport-webusb": "5.53.0",

rollup.config.js

@@ -73,6 +73,7 @@ export default {
     'eth-lattice-keyring',
     'eth-sig-util',
     '@cvbb/eth-keyring',
+    '@keystonehq/eth-keyring',
     'hdkey',
     '@ledgerhq/hw-transport-u2f',
     '@ledgerhq/hw-transport-webusb',

src/@types/index.d.ts

@@ -18,6 +18,7 @@ declare module '@ledgerhq/hw-transport-u2f'
 declare module '@ledgerhq/hw-transport-webusb'
 declare module 'eth-provider'
 declare module '@ensdomains/ensjs'
+declare module '@keystonehq/eth-keyring'
 
 declare module '@shapeshiftoss/hdwallet-core'
 declare module '@shapeshiftoss/hdwallet-keepkey-webusb'

src/interfaces.ts

@@ -252,6 +252,12 @@ export interface LedgerOptions extends CommonWalletOptions {
   customNetwork?: HardwareWalletCustomNetwork
 }
 
+export interface KeystoneOptions extends CommonWalletOptions {
+  appName: string
+  rpcUrl: string
+  customNetwork?: HardwareWalletCustomNetwork
+}
+
 export interface GnosisOptions extends CommonWalletOptions {
   // For default apps (cf. https://github.com/gnosis/safe-apps-list/issues/new/choose)
   appName?: string

src/modules/check/network.ts

@@ -22,7 +22,8 @@ function network(
       walletCheck,
       exit,
       stateSyncStatus,
-      stateStore
+      stateStore,
+      wallet
     } = stateAndHelpers
 
     if (network === null) {
@@ -40,7 +41,14 @@ function network(
         })
       }
     }
-
+    try {
+      await wallet?.provider?.request({
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: '0x' + appNetworkId?.toString(16) }]
+      })
+    } catch (e) {
+      // Could not switch networks so proceed as normal through the checks
+    }
     if (stateStore.network.get() != appNetworkId) {
       return {
         heading: heading || 'You Must Change Networks',

src/modules/select/index.ts

@@ -140,6 +140,8 @@ function getModule(name: string): Promise<{
       return import('./wallets/trezor')
     case 'lattice':
       return import('./wallets/lattice')
+    case 'keystone':
+      return import('./wallets/keystone')
     case 'cobovault':
       return import('./wallets/cobovault')
     case 'ledger':

src/modules/select/wallet-icons/icon-keystone.png

@@ -0,0 +1,285 @@
+import AirGapedKeyring from '@keystonehq/eth-keyring'
+import {
+  Helpers,
+  KeystoneOptions,
+  WalletModule,
+  HardwareWalletCustomNetwork
+} from '../../../interfaces'
+import keystoneIcon from '../wallet-icons/icon-keystone.png'
+import keystoneIcon2x from '../wallet-icons/icon-keystone@2x.png'
+
+function keystone(
+  options: KeystoneOptions & { networkId: number }
+): WalletModule {
+  const {
+    appName,
+    rpcUrl,
+    networkId,
+    preferred,
+    label,
+    iconSrc,
+    svg,
+    customNetwork
+  } = options
+
+  return {
+    name: label || 'Keystone',
+    svg: svg,
+    iconSrc: keystoneIcon,
+    iconSrcSet: iconSrc || keystoneIcon2x,
+    wallet: async (helpers: Helpers) => {
+      const { BigNumber, networkName, resetWalletState } = helpers
+
+      const provider = await keystoneProvider({
+        appName,
+        rpcUrl,
+        networkId,
+        BigNumber,
+        networkName,
+        resetWalletState,
+        customNetwork
+      })
+
+      return {
+        provider,
+        interface: {
+          name: 'Keystone',
+          connect: provider.enable,
+          disconnect: provider.disconnect,
+          address: {
+            get: async () => provider.getPrimaryAddress()
+          },
+          network: {
+            get: async () => networkId
+          },
+          balance: {
+            get: async () => {
+              const address = provider.getPrimaryAddress()
+              return address && provider.getBalance(address)
+            }
+          }
+        }
+      }
+    },
+    type: 'hardware',
+    desktop: true,
+    mobile: true,
+    osExclusions: [],
+    preferred
+  }
+}
+
+async function keystoneProvider(options: {
+  appName: string
+  networkId: number
+  rpcUrl: string
+  BigNumber: any
+  customNetwork?: HardwareWalletCustomNetwork
+  networkName: (id: number) => string
+  resetWalletState: (options?: {
+    disconnected: boolean
+    walletName: string
+  }) => void
+}) {
+  const { Transaction } = await import('@ethereumjs/tx')
+  const { default: Common } = await import('@ethereumjs/common')
+  const { default: createProvider } = await import('./providerEngine')
+
+  const BASE_PATH = "m/44'/60'/0'/0"
+
+  const { networkId, rpcUrl, BigNumber, networkName, customNetwork } = options
+
+  const keyring = AirGapedKeyring.getEmptyKeyring()
+
+  let dPath = ''
+
+  let addressList = Array.from<string>([])
+  let enabled = false
+  let customPath = false
+
+  const provider = createProvider({
+    getAccounts: (callback: any) => {
+      getAccounts()
+        .then((res: Array<string | undefined>) => callback(null, res))
+        .catch((err: any) => callback(err, null))
+    },
+    signTransaction: (transactionData: any, callback: any) => {
+      signTransaction(transactionData)
+        .then((res: string) => callback(null, res))
+        .catch(err => callback(err, null))
+    },
+    processMessage: (messageData: any, callback: any) => {
+      signMessage(messageData)
+        .then((res: string) => callback(null, res))
+        .catch(err => callback(err, null))
+    },
+    processPersonalMessage: (messageData: any, callback: any) => {
+      signMessage(messageData)
+        .then((res: string) => callback(null, res))
+        .catch(err => callback(err, null))
+    },
+    signMessage: (messageData: any, callback: any) => {
+      signMessage(messageData)
+        .then((res: string) => callback(null, res))
+        .catch(err => callback(err, null))
+    },
+    signPersonalMessage: (messageData: any, callback: any) => {
+      signMessage(messageData)
+        .then((res: string) => callback(null, res))
+        .catch(err => callback(err, null))
+    },
+    rpcUrl
+  })
+
+  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 disconnect() {
+    dPath = ''
+    enabled = false
+    provider.stop()
+  }
+
+  async function setPath(path: string) {
+    if (path !== BASE_PATH)
+      throw new Error("Keystone only supports standard path: m/44'/0'/0'/0/x")
+    customPath = false
+    dPath = path
+    return true
+  }
+
+  function isCustomPath() {
+    return customPath
+  }
+
+  function enable() {
+    if (enabled) {
+      return getAccounts()
+    }
+    return keyring.readKeyring().then(() => {
+      enabled = true
+      return getAccounts()
+    })
+  }
+
+  function setPrimaryAccount(address: string) {
+    return keyring.setCurrentAccount(
+      addressList.findIndex(addr => addr === address) || 0
+    )
+  }
+
+  function getPrimaryAddress() {
+    return keyring.getCurrentAddress()
+  }
+
+  async function getMoreAccounts() {
+    const accounts = await getAccounts(true)
+    return accounts && getBalances(accounts)
+  }
+
+  async function getAccounts(getMore?: boolean) {
+    if (!enabled) {
+      return []
+    }
+
+    if (keyring.getAccounts().length > 0 && !getMore) {
+      return keyring.getAccounts()
+    }
+
+    try {
+      addressList = await keyring.addAccounts(keyring.getAccounts().length + 5)
+    } catch (error) {
+      throw error
+    }
+    return addressList
+  }
+
+  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(
+        {
+          jsonrpc: '2.0',
+          method: 'eth_getBalance',
+          params: [address, 'latest'],
+          id: 42
+        },
+        (e: any, res: any) => {
+          e && reject(e)
+          const result = res && res.result
+
+          if (result != null) {
+            resolve(new BigNumber(result).toString(10))
+          } else {
+            resolve(null)
+          }
+        }
+      )
+    })
+  }
+
+  async function signTransaction(transactionData: any) {
+    if (addressList.length === 0) {
+      await enable()
+    }
+
+    const common = new Common({
+      chain: customNetwork || networkName(networkId)
+    })
+
+    const transaction = Transaction.fromTxData(
+      {
+        ...transactionData,
+        gasLimit: transactionData.gas ?? transactionData.gasLimit
+      },
+      { common, freeze: false }
+    )
+
+    try {
+      const signedTx = await keyring.signTransaction(
+        getPrimaryAddress(),
+        transaction
+      )
+      return `0x${signedTx.serialize().toString('hex')}`
+    } catch (err) {
+      throw err
+    }
+  }
+
+  async function signMessage(message: { data: string }): Promise<string> {
+    if (addressList.length === 0) {
+      await enable()
+    }
+
+    try {
+      return keyring.signPersonalMessage(getPrimaryAddress(), message.data)
+    } catch (err) {
+      throw err
+    }
+  }
+
+  return provider
+}
+
+export default keystone