@exodus/headless 2.0.0-alpha.6 → 2.0.0-alpha.61

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@exodus/headless",
-  "version": "2.0.0-alpha.6",
-  "description": "The headless Exodus wallet SDK",
-  "author": "Exodus Movement Inc",
+  "version": "2.0.0-alpha.61",
+  "description": "The platform-agnostic Exodus wallet SDK",
+  "author": "Exodus Movement Inc.",
   "main": "src/index.js",
   "repository": {
     "type": "git",
@@ -17,40 +17,77 @@
     "src",
     "README.md",
     "CHANGELOG.md",
-    "!**/__tests__",
+    "!**/__tests__/**",
     "!**/*.test.js"
   ],
   "scripts": {
     "lint": "eslint . --ignore-path ../../.gitignore",
     "lint:fix": "yarn lint --fix",
-    "test": "jest"
+    "test": "jest --runInBand"
   },
   "dependencies": {
-    "@exodus/atoms": "^2.9.0",
-    "@exodus/dependency-injection": "^1.2.0",
-    "@exodus/dependency-preprocessors": "^2.0.2",
+    "@exodus/ab-testing": "^6.0.0",
+    "@exodus/address-provider": "^5.0.0",
+    "@exodus/apy-rates": "^3.0.0",
+    "@exodus/atoms": "^5.2.1",
+    "@exodus/auto-enable-assets-plugin": "^4.0.1",
+    "@exodus/available-assets": "^2.0.2",
+    "@exodus/balances": "^6.0.1",
+    "@exodus/basic-utils": "^2.0.0",
+    "@exodus/blockchain-metadata": "^8.1.0",
+    "@exodus/config": "^7.0.0",
+    "@exodus/connected-origins": "^2.0.0",
+    "@exodus/crypto-news-monitor": "^3.0.0",
+    "@exodus/dependency-injection": "^2.0.0",
+    "@exodus/dependency-preprocessors": "^2.8.2",
+    "@exodus/enabled-assets": "^6.0.2",
+    "@exodus/exodus-pricing-client": "^1.2.0",
+    "@exodus/feature-flags": "^2.2.0",
+    "@exodus/fee-monitors": "^1.0.0",
     "@exodus/fetch": "^1.2.1",
-    "@exodus/key-identifier-provider": "^1.1.1",
-    "@exodus/keychain": "^3.5.0",
+    "@exodus/fusion": "^6.0.0",
+    "@exodus/geolocation": "^2.0.1",
+    "@exodus/key-identifier-provider": "^1.1.3",
+    "@exodus/keychain": "^4.1.0",
+    "@exodus/kyc": "^4.0.0",
+    "@exodus/market-history": "^3.1.2",
     "@exodus/module": "^1.0.0",
-    "@exodus/wallet": "^5.1.0",
+    "@exodus/nfts": "^2.1.1",
+    "@exodus/rates-monitor": "^2.0.1",
+    "@exodus/top-movers-monitor": "^3.0.0",
+    "@exodus/wallet": "^6.0.1",
     "@exodus/wallet-accounts": "^8.0.1",
-    "@exodus/wallet-compatibility-modes": "1.0.2",
-    "bip39": "2.6.0",
-    "lodash": "https://registry.yarnpkg.com/@exodus/lodash/-/lodash-4.17.21-exodus.2.tgz",
+    "@exodus/wallet-compatibility-modes": "^2.0.0",
+    "bip39": "^2.6.0",
+    "events": "^3.3.0",
+    "lodash": "npm:@exodus/lodash@^4.17.21-exodus.2",
     "minimalistic-assert": "^1.0.1"
   },
   "devDependencies": {
+    "@exodus/algorand-lib": "^2.0.1",
+    "@exodus/algorand-meta": "^1.1.4",
+    "@exodus/bitcoin-lib": "^2.2.1",
+    "@exodus/bitcoin-meta": "^1.0.0",
+    "@exodus/currency": "^2.2.0",
     "@exodus/ethereum-lib": "^2.22.2",
+    "@exodus/ethereum-meta": "^1.0.23",
     "@exodus/models": "^8.11.1",
+    "@exodus/personal-notes": "^3.3.0",
+    "@exodus/referrals": "^6.0.2",
     "@exodus/solana-lib": "^1.3.11",
-    "@exodus/storage-encrypted": "^1.1.1",
-    "@exodus/storage-memory": "^1.1.0",
+    "@exodus/solana-meta": "^1.0.2",
+    "@exodus/storage-encrypted": "^1.1.2",
+    "@exodus/storage-memory": "^2.1.0",
     "@exodus/wild-emitter": "^1.0.0",
     "buffer-json": "^2.0.0",
+    "deepmerge": "^4.2.2",
+    "delay": "^5.0.0",
     "eslint": "^8.33.0",
+    "eslint-plugin-simple-import-sort": "^7.0.0",
+    "events": "^3.3.0",
     "jest": "^29.1.2",
+    "nock": "^13.3.1",
     "p-defer": "^4.0.0"
   },
-  "gitHead": "67a23a4a18114e514e474e5a56eb2545172a60fe"
+  "gitHead": "48de555ca2972a750f2323731d7db3cf63d2839c"
 }

package/src/api.js

@@ -1,43 +1,23 @@
 import { validateMnemonic as isMnemonicValid } from 'bip39'
 
 const createApi = ({ ioc, port }) => {
-  const { passphraseCache } = ioc.getByType('adapter')
+  const apis = ioc.getByType('api')
+  const { remoteConfig } = ioc.getByType('module')
+  const { feeMonitors, nftsMonitor } = ioc.getByType('monitor')
 
-  const { application, wallet, walletAccounts } = ioc.getByType('module')
-  const { enabledWalletAccountsAtom } = ioc.getByType('atom')
+  // TODO: do this on 'unload'
+  const stop = () => {
+    remoteConfig.stop()
+    feeMonitors.stop()
+    nftsMonitor?.stop()
+  }
 
   return {
-    wallet: {
-      exists: () => wallet.exists(),
-      load: application.load,
-      unload: application.unload,
-      create: application.create,
-      lock: application.lock,
-      unlock: application.unlock,
-      import: application.import,
-      delete: application.delete,
-      getMnemonic: application.getMnemonic,
-      setBackedUp: application.setBackedUp,
-      changePassphrase: application.changePassphrase,
-      restoreFromCurrentPhrase: async ({ passphrase } = {}) => {
-        if (!passphrase) passphrase = await passphraseCache.get()
-        const mnemonic = await application.getMnemonic({ passphrase })
-
-        await application.import({ passphrase, mnemonic })
-      },
-      changeLockTimer: application.changeLockTimer,
-      isLocked: () => wallet.isLocked(),
-    },
-    walletAccounts: {
-      create: walletAccounts.create,
-      update: walletAccounts.update,
-      disable: walletAccounts.disable,
-      enable: walletAccounts.enable,
-      getEnabled: enabledWalletAccountsAtom.get,
-    },
+    ...Object.assign({}, ...Object.values(apis)),
     isMnemonicValid,
     subscribe: port.subscribe.bind(port),
     unsubscribe: port.unsubscribe.bind(port),
+    stop,
   }
 }
 

package/src/application.js

@@ -3,6 +3,8 @@
 import ExodusModule from '@exodus/module'
 import assert from 'minimalistic-assert'
 
+import { LifecycleHook as Hook } from './constants'
+
 // Because we are forced to restart wallet after deleting/importing, we need to store certain flags to persist state between executions
 
 // Triggers deletetion logic when wallet starts.
@@ -17,22 +19,7 @@ const IMPORT_FLAG = 'importFlag'
 // Set as true on import method is called, and set to false after restore is completed
 const RESTORE_FLAG = 'restoreFlag'
 
-const HOOKS = Object.freeze({
-  lock: 'lock',
-  unlock: 'unlock',
-  clear: 'clear',
-  import: 'import',
-  migrate: 'migrate',
-  start: 'start',
-  load: 'load',
-  unload: 'unload',
-  create: 'create',
-  backup: 'backup',
-  restore: 'restore',
-  'restore-completed': 'restore-completed',
-  'assets-synced': 'assets-synced',
-  'change-passphrase': 'change-passphrase',
-})
+const HOOKS = new Set(Object.values(Hook))
 
 class Application extends ExodusModule {
   #hooks = {}
@@ -50,6 +37,7 @@ class Application extends ExodusModule {
     this.#storage = unsafeStorage.namespace('flags')
 
     this.#applicationStarted = new Promise((resolve) => (this.#resolveStart = resolve))
+    this.setMaxListeners(Number.POSITIVE_INFINITY)
   }
 
   start = async () => {
@@ -68,12 +56,26 @@ class Application extends ExodusModule {
     const walletExists = await this.#wallet.exists()
 
     if (isImporting || !walletExists) {
-      await this.fire(HOOKS.clear)
+      await this.fire(Hook.Clear)
     }
 
-    if (isImporting) await this.fire(HOOKS.import)
+    if (isImporting) await this.fire(Hook.Import)
+
+    const [hasPassphraseSet, isLocked, isBackedUp, isRestoring] = await Promise.all([
+      this.#wallet.hasPassphraseSet(),
+      this.#wallet.isLocked(),
+      this.#wallet.isBackedUp(),
+      this.isRestoring(),
+    ])
+
+    await this.fire(Hook.Start, {
+      walletExists,
+      hasPassphraseSet,
+      isLocked,
+      isBackedUp,
+      isRestoring,
+    })
 
-    await this.fire(HOOKS.start)
     await this.#autoUnlock()
 
     const locked = await this.#wallet.isLocked()
@@ -93,7 +95,7 @@ class Application extends ExodusModule {
       this.isRestoring(),
     ])
 
-    await this.fire(HOOKS.load, {
+    await this.fire(Hook.Load, {
       walletExists,
       hasPassphraseSet,
       isLocked,
@@ -104,11 +106,11 @@ class Application extends ExodusModule {
   unload = async () => {
     await this.#applicationStarted
     await this.#passphraseCache.scheduleClear()
-    await this.fire(HOOKS.unload)
+    await this.fire(Hook.Unload)
   }
 
   hook = (hookName, listener) => {
-    assert(HOOKS[hookName], `no such hook: ${hookName}`)
+    assert(HOOKS.has(hookName), `no such hook: ${hookName}`)
 
     if (!this.#hooks[hookName]) {
       this.#hooks[hookName] = []
@@ -118,13 +120,18 @@ class Application extends ExodusModule {
   }
 
   fire = async (hookName, params) => {
-    assert(HOOKS[hookName], `no such hook: ${hookName}`)
+    assert(HOOKS.has(hookName), `no such hook: ${hookName}`)
     this._logger.debug('firing hooks', hookName)
 
     const hooks = this.#hooks[hookName] || []
 
     for (let i = 0; i < hooks.length; i++) {
-      await hooks[i](params)
+      try {
+        await hooks[i](params)
+      } catch (err) {
+        this._logger.error(`application lifecycle hook failed: ${hookName}`, hooks[i], params)
+        throw err
+      }
     }
 
     this.emit(hookName, params)
@@ -136,7 +143,15 @@ class Application extends ExodusModule {
     await this.#applicationStarted
     await this.#wallet.create(opts)
 
-    await this.fire(HOOKS.create, { hasPassphraseSet: !!opts?.passphrase })
+    const isLocked = await this.#wallet.isLocked()
+
+    await this.fire(Hook.Create, {
+      hasPassphraseSet: !!opts?.passphrase,
+      isBackedUp: false,
+      isLocked,
+      isRestoring: false,
+      walletExists: true,
+    })
   }
 
   import = async (opts) => {
@@ -148,16 +163,16 @@ class Application extends ExodusModule {
 
     const walletExists = await this.#wallet.exists()
 
-    const { forceRestart, ...wallet } = opts
+    const { forceRestart, forgotPassphrase, ...wallet } = opts
 
     await this.#wallet.import(wallet)
 
     if (forceRestart || walletExists) {
       await this.#storage.set(IMPORT_FLAG, true)
 
-      this.emit('restart', { reason: 'import' })
+      await this.fire(Hook.Restart, { reason: 'import' })
     } else {
-      await this.fire(HOOKS.import)
+      await this.fire(Hook.Import)
 
       this._logger.log('wallet imported')
     }
@@ -167,7 +182,7 @@ class Application extends ExodusModule {
 
   setBackedUp = async () => {
     await this.#wallet.setBackedUp()
-    await this.fire(HOOKS.backup)
+    await this.fire(Hook.Backup)
   }
 
   lock = async (opts) => {
@@ -176,7 +191,7 @@ class Application extends ExodusModule {
     await this.#applicationStarted
     await this.#wallet.lock(opts)
     await this.#passphraseCache.clear()
-    await this.fire(HOOKS.lock)
+    await this.fire(Hook.Lock)
 
     this._logger.log('locked')
   }
@@ -185,13 +200,13 @@ class Application extends ExodusModule {
     const isRestoring = await this.isRestoring()
 
     if (isRestoring) {
-      await this.fire(HOOKS.restore)
+      await this.fire(Hook.Restore)
       await this.#storage.delete(RESTORE_FLAG)
       await this.setBackedUp()
-      await this.fire(HOOKS['restore-completed'])
+      await this.fire(Hook.RestoreCompleted)
     }
 
-    this.fire(HOOKS['assets-synced'])
+    this.fire(Hook.AssetsSynced)
   }
 
   #autoUnlock = async () => {
@@ -204,7 +219,7 @@ class Application extends ExodusModule {
       this._logger.log('unlocking with cache')
 
       await this.#wallet.unlock({ passphrase })
-      await this.fire(HOOKS.unlock)
+      await this.fire(Hook.Unlock)
 
       this.#restoreIfNeeded()
 
@@ -220,8 +235,8 @@ class Application extends ExodusModule {
     await this.#applicationStarted
     await this.#wallet.unlock({ passphrase })
 
-    await this.fire(HOOKS.migrate)
-    await this.fire(HOOKS.unlock)
+    await this.fire(Hook.Migrate)
+    await this.fire(Hook.Unlock)
 
     this.#restoreIfNeeded()
 
@@ -236,14 +251,14 @@ class Application extends ExodusModule {
     await this.#applicationStarted
     await this.#wallet.changePassphrase({ currentPassphrase, newPassphrase })
     await this.#passphraseCache.set(newPassphrase)
-    await this.fire(HOOKS['change-passphrase'])
+    await this.fire(Hook.ChangePassphrase)
 
     this._logger.log('passphrase changed')
   }
 
-  delete = async () => {
+  delete = async ({ forgotPassphrase } = {}) => {
     await this.#storage.set(DELETE_FLAG, true)
-    this.emit('restart', { reason: 'delete' })
+    await this.fire(Hook.Restart, { reason: 'delete', forgotPassphrase })
   }
 
   changeLockTimer = async ({ ttl }) => {

package/src/atoms/attach.js

@@ -0,0 +1,31 @@
+const emitAtomValue = async (opts) => {
+  const { port, atomId, atom } = opts
+  const value = 'value' in opts ? opts.value : await atom.get()
+  port.emit(atomId, value)
+}
+
+export const emitFromAtoms = ({ atoms, port }) =>
+  Object.entries(atoms).forEach(async ([atomId, atom]) => emitAtomValue({ port, atomId, atom }))
+
+const attachAtom = ({ port, application, logger, atom, atomId, lifecycleEvents }) => {
+  let loaded = false
+
+  lifecycleEvents.forEach((event) =>
+    application.on(event, async () => {
+      loaded = true
+      await emitAtomValue({ port, atomId, atom })
+    })
+  )
+
+  atom.observe((value) => {
+    if (loaded) emitAtomValue({ port, atomId, atom, value })
+  })
+}
+
+const attachAtoms = ({ port, application, logger, atoms, lifecycleEvents = ['start'] }) => {
+  for (const [atomId, atom] of Object.entries(atoms)) {
+    attachAtom({ port, application, logger, atom, atomId, lifecycleEvents })
+  }
+}
+
+export default attachAtoms

package/src/atoms/base-asset-names-to-monitor.js

@@ -0,0 +1,37 @@
+import { combine, compute } from '@exodus/atoms'
+import { uniq } from 'lodash'
+
+const getNetworks = (assetNames, assets) =>
+  uniq(
+    assetNames
+      .map((assetName) => assets[assetName]?.baseAsset.name)
+      .filter((assetName) => !!assetName && !assets[assetName].isCombined)
+  )
+
+const createBaseAssetNamesToMonitorAtom = ({
+  assetsModule,
+  enabledAssetsAtom,
+  restoreAtom,
+  availableAssetNamesAtom,
+}) => {
+  const selector = ({ isRestore, enabledAssets, availableAssetNames }) => {
+    const assetNames = isRestore ? availableAssetNames : Object.keys(enabledAssets)
+    return getNetworks(assetNames, assetsModule.getAssets())
+  }
+
+  return compute({
+    atom: combine({
+      isRestore: restoreAtom,
+      enabledAssets: enabledAssetsAtom,
+      availableAssetNames: availableAssetNamesAtom,
+    }),
+    selector,
+  })
+}
+
+export default {
+  id: 'baseAssetNamesToMonitorAtom',
+  type: 'atom',
+  factory: createBaseAssetNamesToMonitorAtom,
+  dependencies: ['assetsModule', 'availableAssetNamesAtom', 'enabledAssetsAtom', 'restoreAtom'],
+}

package/src/constants.js

@@ -0,0 +1,37 @@
+export const atomsToAttach = [
+  'abTestingAtom',
+  'apyRatesAtom',
+  'availableAssetNamesAtom',
+  'balancesAtom',
+  'connectedOriginsAtom',
+  'cryptoNewsAtom',
+  'currencyAtom',
+  'enabledWalletAccountsAtom',
+  'featureFlagsAtom',
+  'geolocationAtom',
+  'kycAtom',
+  'languageAtom',
+  'nftsConfigAtom',
+  'personalNotesAtom',
+  'referralsAtom',
+  'topMoversAtom',
+  'walletAccountsAtom',
+]
+
+export const LifecycleHook = Object.freeze({
+  Lock: 'lock',
+  Unlock: 'unlock',
+  Clear: 'clear',
+  Import: 'import',
+  Migrate: 'migrate',
+  Start: 'start',
+  Restart: 'restart',
+  Load: 'load',
+  Unload: 'unload',
+  Create: 'create',
+  Backup: 'backup',
+  Restore: 'restore',
+  RestoreCompleted: 'restore-completed',
+  AssetsSynced: 'assets-synced',
+  ChangePassphrase: 'change-passphrase',
+})

package/src/dependencies/atoms.js

@@ -1,24 +1,5 @@
-import { createInMemoryAtom } from '@exodus/atoms'
-import {
-  walletAccountsAtomDefinition,
-  enabledWalletAccountsAtomDefinition,
-} from '@exodus/wallet-accounts/atoms'
-import { withType } from './utils'
+import baseAssetNamesToMonitorAtomDefinition from '../atoms/base-asset-names-to-monitor'
 
-const createAtomDependencies = () =>
-  [
-    {
-      definition: {
-        id: 'lockedAtom',
-        factory: () => createInMemoryAtom({ defaultValue: true }),
-        dependencies: [],
-      },
-    },
-    {
-      definition: walletAccountsAtomDefinition,
-      storage: { namespace: 'walletAccounts' },
-    },
-    { definition: enabledWalletAccountsAtomDefinition },
-  ].map(withType('atom'))
+const createAtomDependencies = () => [{ definition: baseAssetNamesToMonitorAtomDefinition }]
 
 export default createAtomDependencies

package/src/dependencies/index.js

@@ -3,10 +3,11 @@
 
 import assert from 'minimalistic-assert'
 
-import createConfigDependencies from './configs'
 import createAdapterDependencies from './adapters'
 import createAtomDependencies from './atoms'
+import createConfigDependencies from './configs'
 import createModuleDependencies from './modules'
+import createPluginDependencies from './plugins'
 import { wrapConstant } from './utils'
 
 const adapterKeys = [
@@ -16,6 +17,9 @@ const adapterKeys = [
   'legacyPrivToPub',
   'seedStorage',
   'unsafeStorage',
+  'fusion',
+  'fetch',
+  'freeze',
 ]
 
 const createDependencies = ({ adapters, config }) => {
@@ -33,11 +37,14 @@ const createDependencies = ({ adapters, config }) => {
 
   const adaptersTree = createAdapterDependencies({ adapters, config })
 
+  const plugins = createPluginDependencies()
+
   return []
     .concat(adaptersTree)
     .concat(configs)
     .concat(modules)
     .concat(atoms)
+    .concat(plugins)
     .concat(wrapConstant({ id: 'logger', type: 'module', value: logger }))
 }
 

package/src/dependencies/modules.js

@@ -1,14 +1,11 @@
-import { createKeychain } from '@exodus/keychain'
-import walletDefinition from '@exodus/wallet/module'
-import walletAccountsDefinition from '@exodus/wallet-accounts/module'
 import createKeyIdentifierProvider from '@exodus/key-identifier-provider'
 import walletCompatibilityModesDefinition from '@exodus/wallet-compatibility-modes/module'
 
 import createApplication from '../application'
-import { withType } from './utils'
 import unlockEncryptedStorageDefinition from '../unlock-encrypted-storage'
+import { withType } from './utils'
 
-const createModuleDependencies = () =>
+const createModuleDependencies = ({ config }) =>
   [
     {
       definition: {
@@ -24,21 +21,10 @@ const createModuleDependencies = () =>
         dependencies: [],
       },
     },
-    {
-      definition: {
-        id: 'keychain',
-        factory: createKeychain,
-        dependencies: ['legacyPrivToPub'],
-      },
-    },
-    {
-      definition: walletDefinition,
-    },
     {
       definition: walletCompatibilityModesDefinition,
     },
     { definition: unlockEncryptedStorageDefinition },
-    { definition: walletAccountsDefinition },
   ].map(withType('module'))
 
 export default createModuleDependencies

package/src/dependencies/plugins.js

@@ -0,0 +1,7 @@
+import plugins from '../plugins'
+import { withType } from './utils'
+
+const createPluginDependencies = () =>
+  plugins.map((definition) => ({ definition })).map(withType('plugin'))
+
+export default createPluginDependencies

package/src/dependencies/utils.js

@@ -2,10 +2,6 @@ export const wrapConstant = ({ id, type, value }) => ({
   definition: { id, type, factory: () => value },
 })
 
-export const insertIf = (module, enabled) => {
-  return enabled ? [module] : []
-}
-
 export const withType =
   (type) =>
   ({ definition, ...rest }) => ({

package/src/features/available-assets/index.js

@@ -0,0 +1,15 @@
+import { availableAssetNamesAtomDefinition } from '@exodus/available-assets/atoms'
+import availableAssetsModuleDefinition from '@exodus/available-assets/module'
+
+const availableAssets = () => ({
+  id: 'availableAssets',
+  definitions: [
+    {
+      definition: { type: 'module', ...availableAssetsModuleDefinition },
+      writesAtoms: ['availableAssetNamesAtom'],
+    },
+    { definition: availableAssetNamesAtomDefinition },
+  ],
+})
+
+export default availableAssets

package/src/features/balances/index.js

@@ -0,0 +1,14 @@
+import { balancesAtomDefinition } from '@exodus/balances/atoms'
+import balancesDefinition from '@exodus/balances/module'
+
+const balances = () => {
+  return {
+    id: 'balances',
+    definitions: [
+      { definition: balancesDefinition, writesAtoms: ['balancesAtom'] },
+      { definition: balancesAtomDefinition },
+    ],
+  }
+}
+
+export default balances

package/src/features/blockchain-metadata/api.js

@@ -0,0 +1,22 @@
+const createBlockchainMetadataApi = ({ blockchainMetadata }) => ({
+  blockchainMetadata: {
+    getTxLog: blockchainMetadata.getTxLog,
+    getLoadedTxLogs: blockchainMetadata.getLoadedTxLogs,
+    updateTxs: blockchainMetadata.updateTxs,
+    overwriteTxs: blockchainMetadata.overwriteTxs,
+    clearTxs: blockchainMetadata.clearTxs,
+    removeTxs: blockchainMetadata.removeTxs,
+    getAccountState: blockchainMetadata.getAccountState,
+    getLoadedAccountStates: blockchainMetadata.getLoadedAccountStates,
+    updateAccountState: blockchainMetadata.updateAccountState,
+    removeAccountState: blockchainMetadata.removeAccountState,
+    batch: blockchainMetadata.batch,
+  },
+})
+
+export default {
+  id: 'createBlockchainMetadataApi',
+  type: 'api',
+  factory: createBlockchainMetadataApi,
+  dependencies: ['blockchainMetadata'],
+}