@exodus/headless 2.0.0-alpha.2 → 2.0.0-alpha.21

package/src/application.js

@@ -17,23 +17,25 @@ 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 Hook = Object.freeze({
+  Lock: 'lock',
+  Unlock: 'unlock',
+  Clear: 'clear',
+  Import: 'import',
+  Migrate: 'migrate',
+  Start: 'start',
+  Load: 'load',
+  Unload: 'unload',
+  Create: 'create',
+  Backup: 'backup',
+  Restore: 'restore',
+  RestoreCompleted: 'restore-completed',
+  AssetsSynced: 'assets-synced',
+  ChangePassphrase: 'change-passphrase',
 })
 
+const HOOKS = new Set(Object.values(Hook))
+
 class Application extends ExodusModule {
   #hooks = {}
   #wallet = null
@@ -50,6 +52,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 () => {
@@ -63,12 +66,17 @@ class Application extends ExodusModule {
     if (isDeleting || isImporting) {
       await this.#storage.batchDelete([DELETE_FLAG, IMPORT_FLAG])
       await this.#passphraseCache.clear()
-      await this.fire(HOOKS.clear)
     }
 
-    if (isImporting) await this.fire(HOOKS.import)
+    const walletExists = await this.#wallet.exists()
+
+    if (isImporting || !walletExists) {
+      await this.fire(Hook.Clear)
+    }
 
-    await this.fire(HOOKS.start)
+    if (isImporting) await this.fire(Hook.Import)
+
+    await this.fire(Hook.Start)
     await this.#autoUnlock()
 
     const locked = await this.#wallet.isLocked()
@@ -88,7 +96,7 @@ class Application extends ExodusModule {
       this.isRestoring(),
     ])
 
-    await this.fire(HOOKS.load, {
+    await this.fire(Hook.Load, {
       walletExists,
       hasPassphraseSet,
       isLocked,
@@ -99,11 +107,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] = []
@@ -113,7 +121,7 @@ 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] || []
@@ -131,7 +139,7 @@ class Application extends ExodusModule {
     await this.#applicationStarted
     await this.#wallet.create(opts)
 
-    await this.fire(HOOKS.create, { hasPassphraseSet: !!opts?.passphrase })
+    await this.fire(Hook.Create, { hasPassphraseSet: !!opts?.passphrase })
   }
 
   import = async (opts) => {
@@ -141,26 +149,28 @@ class Application extends ExodusModule {
 
     await this.#applicationStarted
 
-    if (await this.#wallet.exists()) {
-      await this.#wallet.import(opts)
+    const walletExists = await this.#wallet.exists()
+
+    const { forceRestart, ...wallet } = opts
+
+    await this.#wallet.import(wallet)
+
+    if (forceRestart || walletExists) {
       await this.#storage.set(IMPORT_FLAG, true)
 
       this.emit('restart', { reason: 'import' })
+    } else {
+      await this.fire(Hook.Import)
 
-      return
+      this._logger.log('wallet imported')
     }
-
-    await this.#wallet.import(opts)
-    await this.fire(HOOKS.import)
-
-    this._logger.log('wallet imported')
   }
 
   getMnemonic = async (opts) => this.#wallet.getMnemonic(opts)
 
   setBackedUp = async () => {
     await this.#wallet.setBackedUp()
-    await this.fire(HOOKS.backup)
+    await this.fire(Hook.Backup)
   }
 
   lock = async (opts) => {
@@ -169,7 +179,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')
   }
@@ -178,13 +188,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 () => {
@@ -197,7 +207,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()
 
@@ -213,8 +223,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()
 
@@ -229,7 +239,7 @@ 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')
   }

package/src/atoms/attach.js

@@ -0,0 +1,40 @@
+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 })
+    })
+  )
+
+  application.on('clear', async () => {
+    try {
+      await atom?.set(undefined)
+    } catch (error) {
+      logger.debug('failed to clear atom', error)
+      // noop. atom might not support set
+    }
+  })
+
+  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/constants.js

@@ -0,0 +1,12 @@
+export const atomsToAttach = [
+  'availableAssetNamesAtom',
+  'balancesAtom',
+  'currencyAtom',
+  'enabledWalletAccountsAtom',
+  'featureFlagsAtom',
+  'geolocationAtom',
+  'kycAtom',
+  'languageAtom',
+  'referralsAtom',
+  'walletAccountsAtom',
+]

package/src/dependencies/atom-collections.js

@@ -0,0 +1,25 @@
+import {
+  featureFlagAtomsDefinition,
+  remoteConfigFeatureFlagAtomsDefinition,
+} from '@exodus/feature-flags/atoms'
+
+import { withType } from './utils'
+
+const createAtomCollectionDependencies = () =>
+  [
+    {
+      definition: remoteConfigFeatureFlagAtomsDefinition,
+    },
+    {
+      definition: featureFlagAtomsDefinition,
+      storage: { namespace: 'featureFlags' },
+      aliases: [
+        {
+          implementationId: 'unsafeStorage',
+          interfaceId: 'storage',
+        },
+      ],
+    },
+  ].map(withType('atom-collection'))
+
+export default createAtomCollectionDependencies

package/src/dependencies/atoms.js

@@ -1,5 +1,26 @@
-import { createInMemoryAtom } from '@exodus/atoms'
+import {
+  createInMemoryAtom,
+  createRemoteConfigAtomFactory,
+  createStorageAtomFactory,
+  createFusionAtomFactory,
+} from '@exodus/atoms'
+import {
+  walletAccountsAtomDefinition,
+  enabledWalletAccountsAtomDefinition,
+} from '@exodus/wallet-accounts/atoms'
+import {
+  enabledAndDisabledAssetsAtomDefinition,
+  enabledAssetsAtomDefinition,
+} from '@exodus/enabled-assets/atoms'
+import { availableAssetNamesAtomDefinition } from '@exodus/available-assets/atoms'
+import { ratesAtomDefinition } from '@exodus/rates-monitor/atoms'
+import { balancesAtomDefinition } from '@exodus/balances/atoms'
+import { featureFlagsAtomDefinition } from '@exodus/feature-flags/atoms'
+import { kycAtomDefinition } from '@exodus/kyc/atoms'
+import { referralsAtomDefinition } from '@exodus/referrals/atoms'
+
 import { withType } from './utils'
+import { geolocationAtomDefinition } from '@exodus/geolocation/atoms'
 
 const createAtomDependencies = () =>
   [
@@ -10,6 +31,109 @@ const createAtomDependencies = () =>
         dependencies: [],
       },
     },
+    {
+      definition: walletAccountsAtomDefinition,
+      storage: { namespace: 'walletAccounts' },
+    },
+    { definition: enabledWalletAccountsAtomDefinition },
+    {
+      definition: enabledAndDisabledAssetsAtomDefinition,
+      storage: { namespace: 'enabledAssets' },
+    },
+    { definition: enabledAssetsAtomDefinition },
+    { definition: availableAssetNamesAtomDefinition },
+    {
+      definition: {
+        id: 'pricingServerUrlAtom',
+        factory: ({ config, remoteConfig }) =>
+          createRemoteConfigAtomFactory({ remoteConfig })({
+            path: config.pricingServerPath,
+            defaultValue: config.defaultPricingServerUrl,
+          }),
+        dependencies: ['config', 'remoteConfig'],
+      },
+    },
+    {
+      definition: {
+        id: 'languageAtom',
+        factory: ({ storage, config }) =>
+          createStorageAtomFactory({ storage })({
+            key: 'language',
+            defaultValue: config.defaultValue,
+            isSoleWriter: true,
+          }),
+        dependencies: ['storage', 'config'],
+      },
+      aliases: [
+        {
+          implementationId: 'unsafeStorage',
+          interfaceId: 'storage',
+        },
+      ],
+      storage: { namespace: 'locale' },
+    },
+    {
+      definition: {
+        id: 'currencyAtom',
+        factory: ({ fusion, config }) =>
+          createFusionAtomFactory({ fusion })({
+            path: `private.currency`,
+            defaultValue: config.defaultValue,
+          }),
+        dependencies: ['fusion', 'config'],
+      },
+    },
+    // TODO: move to @exodus/market-history
+    {
+      definition: {
+        id: 'marketHistoryClearCacheAtom',
+        factory: ({ config }) => createInMemoryAtom(config),
+        dependencies: ['config'],
+      },
+    },
+    // TODO: move to @exodus/market-history
+    {
+      definition: {
+        id: 'remoteConfigClearMarketHistoryCacheAtom',
+        factory: ({ config, remoteConfig }) =>
+          createRemoteConfigAtomFactory({ remoteConfig })(config),
+        dependencies: ['config', 'remoteConfig'],
+      },
+    },
+    // TODO: move to @exodus/market-history
+    {
+      definition: {
+        id: 'marketHistoryRefreshIntervalAtom',
+        factory: ({ config, remoteConfig }) =>
+          createRemoteConfigAtomFactory({ remoteConfig })(config),
+        dependencies: ['config', 'remoteConfig'],
+      },
+    },
+    {
+      definition: {
+        id: 'mockConfigAtom',
+        factory: ({ storage }) =>
+          createStorageAtomFactory({ storage })({
+            key: 'mockConfig',
+            defaultValue: {},
+            isSoleWriter: true,
+          }),
+        dependencies: ['storage'],
+      },
+      storage: { namespace: 'mockConfig' },
+      aliases: [
+        {
+          implementationId: 'unsafeStorage',
+          interfaceId: 'storage',
+        },
+      ],
+    },
+    { definition: balancesAtomDefinition },
+    { definition: ratesAtomDefinition },
+    { definition: geolocationAtomDefinition },
+    { definition: featureFlagsAtomDefinition },
+    { definition: kycAtomDefinition },
+    { definition: referralsAtomDefinition },
   ].map(withType('atom'))
 
 export default createAtomDependencies

package/src/dependencies/index.js

@@ -6,8 +6,11 @@ import assert from 'minimalistic-assert'
 import createConfigDependencies from './configs'
 import createAdapterDependencies from './adapters'
 import createAtomDependencies from './atoms'
+import createAtomCollectionDependencies from './atom-collections'
 import createModuleDependencies from './modules'
+import createMonitorDependencies from './monitors'
 import { wrapConstant } from './utils'
+import createPluginDependencies from './plugins'
 
 const adapterKeys = [
   // ...
@@ -16,6 +19,9 @@ const adapterKeys = [
   'legacyPrivToPub',
   'seedStorage',
   'unsafeStorage',
+  'fusion',
+  'fetch',
+  'freeze',
 ]
 
 const createDependencies = ({ adapters, config }) => {
@@ -29,15 +35,24 @@ const createDependencies = ({ adapters, config }) => {
 
   const modules = createModuleDependencies({ adapters, config })
 
+  const monitors = createMonitorDependencies({ adapters, config })
+
   const atoms = createAtomDependencies({ adapters, config })
 
+  const atomCollections = createAtomCollectionDependencies({ adapters, config })
+
   const adaptersTree = createAdapterDependencies({ adapters, config })
 
+  const plugins = createPluginDependencies()
+
   return []
     .concat(adaptersTree)
     .concat(configs)
     .concat(modules)
+    .concat(monitors)
     .concat(atoms)
+    .concat(atomCollections)
+    .concat(plugins)
     .concat(wrapConstant({ id: 'logger', type: 'module', value: logger }))
 }
 

package/src/dependencies/modules.js

@@ -1,12 +1,27 @@
-import { createKeychain } from '@exodus/keychain'
+import EventEmitter from 'events/'
+import createRemoteConfig from '@exodus/config/remote'
+import keychainDefinition from '@exodus/keychain/module'
 import walletDefinition from '@exodus/wallet/module'
+import walletAccountsDefinition from '@exodus/wallet-accounts/module'
+import blockchainMetadataDefinition from '@exodus/blockchain-metadata/module'
+import enabledAssetsModuleDefinition from '@exodus/enabled-assets/module'
+import availableAssetsModuleDefinition from '@exodus/available-assets/module'
 import createKeyIdentifierProvider from '@exodus/key-identifier-provider'
 import walletCompatibilityModesDefinition from '@exodus/wallet-compatibility-modes/module'
+import balancesDefinition from '@exodus/balances/module'
+import featureFlagsDefinition from '@exodus/feature-flags/module'
+import createAddressesProvider from '@exodus/addresses-provider'
+import createMockableAddressesProvider from '@exodus/addresses-provider/mock'
+import createInMemoryAddressCache from '@exodus/addresses-provider/address-cache-memory'
+import createExodusPricingClient from '@exodus/exodus-pricing-client'
+import kycDefinition from '@exodus/kyc/module'
+import referralsDefinition from '@exodus/referrals/module'
 
 import createApplication from '../application'
 import { withType } from './utils'
+import unlockEncryptedStorageDefinition from '../unlock-encrypted-storage'
 
-const createModuleDependencies = () =>
+const createModuleDependencies = ({ config }) =>
   [
     {
       definition: {
@@ -23,18 +38,94 @@ const createModuleDependencies = () =>
       },
     },
     {
-      definition: {
-        id: 'keychain',
-        factory: createKeychain,
-        dependencies: ['legacyPrivToPub'],
-      },
+      definition: keychainDefinition,
     },
     {
       definition: walletDefinition,
+      writesAtoms: ['lockedAtom'],
     },
     {
       definition: walletCompatibilityModesDefinition,
     },
+    { definition: unlockEncryptedStorageDefinition },
+    { definition: walletAccountsDefinition, writesAtoms: ['walletAccountsAtom'] },
+    {
+      definition: blockchainMetadataDefinition,
+      storage: { namespace: ['blockchain', 'v1'] },
+    },
+    { definition: enabledAssetsModuleDefinition, writesAtoms: ['enabledAndDisabledAssetsAtom'] },
+    {
+      definition: {
+        id: 'remoteConfig',
+        factory: (deps) => {
+          const eventEmitter = new EventEmitter().setMaxListeners(Number.POSITIVE_INFINITY)
+          return createRemoteConfig({ eventEmitter, ...deps })
+        },
+        dependencies: ['fetch', 'freeze', 'config', 'logger'],
+      },
+    },
+    { definition: availableAssetsModuleDefinition, writesAtoms: ['availableAssetNamesAtom'] },
+    {
+      definition: {
+        id: 'pricingClient',
+        factory: createExodusPricingClient,
+        dependencies: ['fetch', 'pricingServerUrlAtom'],
+      },
+    },
+    { definition: balancesDefinition, writesAtoms: ['balancesAtom'] },
+    {
+      definition: featureFlagsDefinition,
+      writesAtoms: ['featureFlagAtoms'],
+    },
+    {
+      definition: {
+        id: 'addressCache',
+        factory: createInMemoryAddressCache,
+      },
+    },
+    config.addressesProvider?.mockAddresses
+      ? {
+          definition: {
+            id: 'addressesProvider',
+            factory: createMockableAddressesProvider,
+            dependencies: [
+              'assetsModule',
+              'keychain',
+              'keyIdentifierProvider',
+              'blockchainMetadata',
+              'addressCache',
+              'mockConfigAtom',
+            ],
+          },
+        }
+      : {
+          definition: {
+            id: 'addressesProvider',
+            factory: createAddressesProvider,
+            dependencies: [
+              'assetsModule',
+              'keychain',
+              'keyIdentifierProvider',
+              'blockchainMetadata',
+              'addressCache',
+            ],
+          },
+        },
+    {
+      definition: kycDefinition,
+      writesAtoms: ['kycAtom'],
+    },
+    {
+      definition: referralsDefinition,
+      storage: { namespace: 'referrals' },
+      writesAtoms: ['referralsAtom'],
+      aliases: [
+        {
+          implementationId: 'unsafeStorage',
+          interfaceId: 'storage',
+        },
+      ],
+    },
   ].map(withType('module'))
 
 export default createModuleDependencies

package/src/dependencies/monitors.js

@@ -0,0 +1,35 @@
+import marketHistoryMonitorDefinition from '@exodus/market-history/module'
+import ratesMonitorDefinition from '@exodus/rates-monitor/module'
+
+import { withType } from './utils'
+import geolocationMonitorDefinition from '@exodus/geolocation/monitor'
+
+const createMonitorDependencies = () =>
+  [
+    { definition: geolocationMonitorDefinition },
+    {
+      definition: marketHistoryMonitorDefinition,
+      storage: { namespace: 'marketHistory' },
+      aliases: [
+        {
+          implementationId: 'unsafeStorage',
+          interfaceId: 'storage',
+        },
+        {
+          implementationId: 'marketHistoryClearCacheAtom',
+          interfaceId: 'clearCacheAtom',
+        },
+        {
+          implementationId: 'remoteConfigClearMarketHistoryCacheAtom',
+          interfaceId: 'remoteConfigClearCacheAtom',
+        },
+        {
+          implementationId: 'marketHistoryRefreshIntervalAtom',
+          interfaceId: 'remoteConfigRefreshIntervalAtom',
+        },
+      ],
+    },
+    { definition: ratesMonitorDefinition, writesAtoms: ['ratesAtom'] },
+  ].map(withType('monitor'))
+
+export default createMonitorDependencies

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