@exodus/headless 2.0.0-alpha.149 → 2.0.0-alpha.15

package/src/dependencies/atoms.js

@@ -1,5 +1,120 @@
-import baseAssetNamesToMonitorAtomDefinition from '../atoms/base-asset-names-to-monitor'
+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 createGeolocationAtom from '@exodus/geolocation'
 
-const createAtomDependencies = () => [{ definition: baseAssetNamesToMonitorAtomDefinition }]
+import { withType } from './utils'
+
+const createAtomDependencies = () =>
+  [
+    {
+      definition: {
+        id: 'lockedAtom',
+        factory: () => createInMemoryAtom({ defaultValue: true }),
+        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: balancesAtomDefinition },
+    { definition: ratesAtomDefinition },
+    {
+      definition: {
+        id: 'geolocationAtom',
+        factory: createGeolocationAtom,
+        dependencies: ['config'],
+      },
+    },
+  ].map(withType('atom'))
 
 export default createAtomDependencies

package/src/dependencies/index.js

@@ -3,18 +3,22 @@
 
 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 createMonitorDependencies from './monitors'
 import { wrapConstant } from './utils'
+import createPluginDependencies from './plugins'
 
 const adapterKeys = [
+  // ...
+  'assetsModule',
   'createLogger',
   'legacyPrivToPub',
   'seedStorage',
   'unsafeStorage',
+  'fusion',
   'fetch',
   'freeze',
 ]
@@ -30,6 +34,8 @@ const createDependencies = ({ adapters, config }) => {
 
   const modules = createModuleDependencies({ adapters, config })
 
+  const monitors = createMonitorDependencies({ adapters, config })
+
   const atoms = createAtomDependencies({ adapters, config })
 
   const adaptersTree = createAdapterDependencies({ adapters, config })
@@ -40,6 +46,7 @@ const createDependencies = ({ adapters, config }) => {
     .concat(adaptersTree)
     .concat(configs)
     .concat(modules)
+    .concat(monitors)
     .concat(atoms)
     .concat(plugins)
     .concat(wrapConstant({ id: 'logger', type: 'module', value: logger }))

package/src/dependencies/modules.js

@@ -1,17 +1,27 @@
+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 createApplication from '../application'
-import unlockEncryptedStorageDefinition from '../unlock-encrypted-storage'
 import { withType } from './utils'
+import unlockEncryptedStorageDefinition from '../unlock-encrypted-storage'
+import createExodusPricingClient from '@exodus/exodus-pricing-client'
 
-const createModuleDependencies = ({ config }) =>
+const createModuleDependencies = () =>
   [
     {
       definition: {
         id: 'application',
         factory: createApplication,
-        dependencies: ['unsafeStorage', 'passphraseCache?', 'wallet', 'logger'],
+        dependencies: ['unsafeStorage', 'passphraseCache', 'wallet', 'logger'],
       },
     },
     {
@@ -21,12 +31,42 @@ const createModuleDependencies = ({ config }) =>
         dependencies: [],
       },
     },
+    {
+      definition: keychainDefinition,
+    },
+    {
+      definition: walletDefinition,
+      writesAtoms: ['lockedAtom'],
+    },
     {
       definition: walletCompatibilityModesDefinition,
-      storage: { namespace: 'walletCompatibilityModes' },
-      aliases: [{ implementationId: 'unsafeStorage', interfaceId: 'storage' }],
     },
     { 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'] },
   ].map(withType('module'))
 
 export default createModuleDependencies

package/src/dependencies/monitors.js

@@ -0,0 +1,33 @@
+import marketHistoryMonitorDefinition from '@exodus/market-history/module'
+import ratesMonitorDefinition from '@exodus/rates-monitor/module'
+
+import { withType } from './utils'
+
+const createModuleDependencies = () =>
+  [
+    {
+      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 createModuleDependencies

package/src/dependencies/utils.js

@@ -2,6 +2,10 @@ 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/index.js

@@ -1,125 +1,114 @@
-import addressProvider from '@exodus/address-provider'
-import assetsFeature from '@exodus/assets-feature'
-import availableAssets from '@exodus/available-assets'
-import balances from '@exodus/balances'
-import blockchainMetadata from '@exodus/blockchain-metadata'
-import enabledAssets from '@exodus/enabled-assets'
-import featureFlags from '@exodus/feature-flags'
-import fees from '@exodus/fee-data-monitors'
-import geolocation from '@exodus/geolocation'
-import keychain from '@exodus/keychain'
-import locale from '@exodus/locale'
-import pricing from '@exodus/pricing'
-import publicKeyStore from '@exodus/public-key-store'
-import rates from '@exodus/rates-monitor'
-import remoteConfig from '@exodus/remote-config'
-import restoreProgressTracker from '@exodus/restore-progress-tracker'
-import startupCounter from '@exodus/startup-counter'
-import transactionSigner from '@exodus/tx-signer'
-import wallet from '@exodus/wallet'
-import walletAccounts from '@exodus/wallet-accounts'
-
-import createApi from './api'
+import { pick } from '@exodus/basic-utils'
 import createIOC from './ioc'
-import attachMigrations from './migrations/attach'
+import createApi from './api'
+import {
+  createAccountStatesUpdateHandler,
+  createLoadWalletAccountsHandler,
+} from './utils/blockchain-metadata'
+
 import attachPlugins from './plugins/attach'
+import attachAtoms from './atoms/attach'
+import { atomsToAttach } from './constants'
 
 const createExodus = ({ adapters, config, port }) => {
   const ioc = createIOC({ adapters, config })
-
-  ioc.use(addressProvider({ config: config.addressProvider }))
-  ioc.use(assetsFeature())
-  ioc.use(availableAssets())
-  ioc.use(balances(config.balances))
-  ioc.use(blockchainMetadata())
-  ioc.use(enabledAssets())
-  ioc.use(featureFlags())
-  ioc.use(fees())
-  ioc.use(geolocation())
-  ioc.use(keychain(config.keychain))
-  ioc.use(locale())
-  ioc.use(pricing())
-  ioc.use(publicKeyStore())
-  ioc.use(rates())
-  ioc.use(remoteConfig())
-  ioc.use(restoreProgressTracker())
-  ioc.use(startupCounter())
-  ioc.use(transactionSigner())
-  ioc.use(wallet())
-  ioc.use(walletAccounts())
-
-  ioc.register({ definition: { id: 'port', type: 'port', factory: () => port } })
+  const { headless: headlessConfig } = config
 
   const resolve = () => {
     ioc.resolve()
 
-    const { storage, migrateableStorage } = ioc.getByType('adapter')
-
-    const { application, wallet, unlockEncryptedStorage } = ioc.getByType('module')
-
-    const { migrations } = ioc.getAll()
-
-    application.on('start', (payload) => port.emit('start', payload))
-
-    application.hook('load', (args) => port.emit('pre-load', args))
-
-    application.on('load', (args) => port.emit('load', args))
-
-    application.on('create', async ({ hasPassphraseSet }) => {
-      const isLocked = await wallet.isLocked()
+    const { assetsModule, storage } = ioc.getByType('adapter')
 
-      port.emit('create', {
-        walletExists: true,
-        hasPassphraseSet,
-        isLocked,
-        isBackedUp: false,
-        isRestoring: false,
-      })
+    const {
+      application,
+      blockchainMetadata,
+      enabledAssets,
+      remoteConfig,
+      unlockEncryptedStorage,
+      walletAccounts,
+    } = ioc.getByType('module')
+
+    const { marketHistory, ratesMonitor } = ioc.getByType('monitor')
+
+    const handleLoadWalletAccounts = createLoadWalletAccountsHandler({
+      blockchainMetadata,
+      port,
+      config,
     })
 
-    application.on('unlock', () => port.emit('unlock'))
+    const handleAccountStatesUpdate = createAccountStatesUpdateHandler({
+      blockchainMetadata,
+      port,
+      config,
+    })
 
-    application.on('lock', () => port.emit('lock'))
+    blockchainMetadata.on('load-wallet-accounts', handleLoadWalletAccounts)
+    blockchainMetadata.on('tx-logs-update', (payload) => port.emit('tx-logs-update', payload))
+    blockchainMetadata.on('account-states-update', handleAccountStatesUpdate)
 
-    application.on('backup', () => port.emit('backup'))
+    remoteConfig.on('sync', ({ current }) => port.emit('remote-config', current))
 
-    application.on('restore', () => port.emit('restore'))
+    // TODO: migrate to marketHistoryAtom. Will be easier once it's on headless
+    marketHistory.on('market-history', (payload) => port.emit('market-history', payload))
 
-    application.on('restore-completed', () => {
-      port.emit('restore-completed')
-    })
+    // TODO: migrate to ratesAtom. Will be easier once it's on headless
+    ratesMonitor.on('rates', (payload) => port.emit('rates', payload))
 
-    application.on('change-passphrase', () => port.emit('passphrase-changed'))
+    application.hook('start', () => {
+      remoteConfig.load()
 
-    application.on('import', () => port.emit('import', { walletExists: true }))
+      port.emit('start')
+    })
 
     application.hook('unlock', async () => {
       if (typeof storage.unlock === 'function') unlockEncryptedStorage(storage)
 
-      // normally unlocked during migrations, also unlock here just in case
-      if (typeof migrateableStorage.unlock === 'function')
-        unlockEncryptedStorage(migrateableStorage)
+      remoteConfig.sync()
+      marketHistory.start()
+      ratesMonitor.start()
+
+      await assetsModule.load()
+      await walletAccounts.load()
+      await Promise.all([
+        //
+        blockchainMetadata.load(),
+        enabledAssets.load(),
+      ])
+    })
+
+    application.on('unlock', () => {
+      port.emit('unlock')
     })
 
-    application.on('clear', () => port.emit('clear'))
+    application.hook('clear', async () => {
+      await Promise.all([
+        //
+        assetsModule.clear(),
+        walletAccounts.clear(),
+        blockchainMetadata.clear(),
+        enabledAssets.clear(),
+      ])
 
-    application.on('restart', (payload) => port.emit('restart', payload))
+      port.emit('clear')
+    })
 
-    attachMigrations({
-      migrations,
-      adapters,
-      application,
-      atoms: ioc.getByType('atom'),
-      modules: ioc.getByType('module'),
+    application.on('restart', (payload) => {
+      port.emit('restart', payload)
     })
 
-    attachPlugins({
+    attachAtoms({
+      port,
       application,
-      plugins: ioc.getByType('plugin'),
-      logger: ioc.get('createLogger')('attachPlugins'),
+      logger: ioc.get('createLogger')('attachAtoms'),
+      atoms: pick(ioc.getByType('atom'), atomsToAttach),
+      lifecycleEvents: headlessConfig?.attachAtomsLifecycleEvents,
     })
 
-    return createApi({ ioc, port, config })
+    attachPlugins({ application, plugins: ioc.getByType('plugin') })
+
+    application.start()
+
+    return createApi({ ioc, port })
   }
 
   return { ...ioc, resolve }

package/src/ioc.js

@@ -1,43 +1,22 @@
 import createIocContainer from '@exodus/dependency-injection'
 import preprocess from '@exodus/dependency-preprocessors'
 import alias from '@exodus/dependency-preprocessors/src/preprocessors/alias'
-import configPreprocessor from '@exodus/dependency-preprocessors/src/preprocessors/config'
-import devModeAtoms from '@exodus/dependency-preprocessors/src/preprocessors/dev-mode-atoms'
 import logify from '@exodus/dependency-preprocessors/src/preprocessors/logify'
+import namespaceConfig from '@exodus/dependency-preprocessors/src/preprocessors/namespace-config'
 import namespaceStorage from '@exodus/dependency-preprocessors/src/preprocessors/namespace-storage'
-import optional from '@exodus/dependency-preprocessors/src/preprocessors/optional'
-import performanceMonitor from '@exodus/dependency-preprocessors/src/preprocessors/performance-monitor'
 import readOnlyAtoms from '@exodus/dependency-preprocessors/src/preprocessors/read-only-atoms'
-import assert from 'minimalistic-assert'
 
 import createDependencies from './dependencies'
 
 const createIOC = ({ adapters, config }) => {
-  const { createLogger, performance = {} } = adapters
-  const {
-    readOnlyAtoms: readOnlyAtomsConfig,
-    devModeAtoms: devModeAtomsConfig,
-    performanceMonitor: performanceMonitorConfig,
-  } = config.ioc ?? {}
-
-  const ioc = createIocContainer({ logger: createLogger('exodus:ioc') })
-
-  const performanceLogger = createLogger('exodus:performance')
+  const { createLogger } = adapters
+  const { readOnlyAtoms: readOnlyAtomsConfig } = config.ioc ?? {}
 
+  const logger = createLogger('exodus:ioc')
+  const dependencies = createDependencies({ adapters, config })
   const preprocessors = [
     logify({ createLogger }),
-    performanceMonitorConfig?.enabled &&
-      performanceMonitor({
-        now: performance.now,
-        onAboveThreshold:
-          performance.onAboveThreshold ??
-          (({ id, method, async, duration }) =>
-            performanceLogger.log(
-              `${id}.${method} ${async ? 'resolved after' : 'took'} ${duration}ms`
-            )),
-        config: performanceMonitorConfig,
-      }),
-    configPreprocessor(),
+    namespaceConfig(),
     alias(),
     // NOTE: order matters, this should come after `alias`
     namespaceStorage(),
@@ -46,30 +25,13 @@ const createIOC = ({ adapters, config }) => {
       warn: true,
       ...readOnlyAtomsConfig,
     }),
-    optional(),
-    devModeAtomsConfig && devModeAtoms(devModeAtomsConfig),
-  ].filter(Boolean)
-
-  const registerMultiple = (dependencies) => {
-    ioc.registerMultiple(preprocess({ dependencies, preprocessors }))
-  }
-
-  const register = (dependency) => {
-    registerMultiple([dependency])
-  }
-
-  const use = (feature) => {
-    for (const { definition } of feature.definitions) {
-      assert(definition.type, `ioc.use: "${definition.id}" is missing type field`)
-      definition.namespace = feature.id
-    }
-
-    registerMultiple(feature.definitions)
-  }
+  ]
+  const definitions = preprocess({ dependencies, preprocessors })
+  const ioc = createIocContainer({ logger })
 
-  registerMultiple(createDependencies({ adapters, config }))
+  ioc.registerMultiple(definitions)
 
-  return { ...ioc, register, registerMultiple, use }
+  return ioc
 }
 
 export default createIOC

package/src/plugins/attach.js

@@ -1,38 +1,17 @@
-import { LifecycleHook } from '../constants'
+import { kebabCase, memoize } from 'lodash'
 
-const LIFECYCLE_METHOD_TO_HOOK_NAME = Object.fromEntries(
-  Object.entries(LifecycleHook).map(([pascalCaseName, hookName]) => [
-    `on${pascalCaseName}`,
-    hookName,
-  ])
+// e.g. onUnlock -> unlock -> onUnlock, onChangePassphrase -> change-passphrase
+const getApplicationHookName = memoize((lifecycleMethod) =>
+  kebabCase(lifecycleMethod.replace(/^on/, ''))
 )
 
-const attachPlugins = ({ plugins, application, logger }) => {
-  const timeFn = (fn, name) => {
-    const pluginWrapper = async (...args) => {
-      const start = Date.now()
-      try {
-        return await fn(...args)
-      } finally {
-        logger.debug(name, `${Date.now() - start}ms`)
-      }
-    }
-
-    Object.defineProperty(pluginWrapper, 'name', { value: name, writable: false })
-
-    return pluginWrapper
-  }
-
+const attachPlugins = ({ plugins, application }) => {
   Object.entries(plugins).forEach(([name, lifecycleMethods]) => {
     const entries = Object.entries(lifecycleMethods || {})
 
     for (const [lifecycleMethod, fn] of entries) {
-      const hookName = LIFECYCLE_METHOD_TO_HOOK_NAME[lifecycleMethod]
-      if (hookName) {
-        application.hook(hookName, timeFn(fn, `plugin ${name}.${lifecycleMethod}`))
-      } else {
-        logger.error(`plugin "${name}" declares unsupported lifecycle method "${lifecycleMethod}"`)
-      }
+      const hookName = getApplicationHookName(lifecycleMethod)
+      application.hook(hookName, fn)
     }
   })
 }

package/src/plugins/index.js

@@ -1,5 +1,3 @@
-import autoEnableAssetsPlugin from '@exodus/auto-enable-assets-plugin'
-
 import logLifecyclePlugin from './log-lifecycle'
 
-export default [logLifecyclePlugin, autoEnableAssetsPlugin]
+export default [logLifecyclePlugin]

package/src/plugins/log-lifecycle.js

@@ -9,7 +9,6 @@ const logLifecycle = {
       onImport: () => logger.debug('onImport'),
       onMigrate: () => logger.debug('onMigrate'),
       onStart: () => logger.debug('onStart'),
-      onRestart: () => logger.debug('onRestart'),
       onLoad: () => logger.debug('onLoad'),
       onUnload: () => logger.debug('onUnload'),
       onCreate: () => logger.debug('onCreate'),

package/src/unlock-encrypted-storage.js

@@ -12,10 +12,8 @@ const createUnlockEncryptedStorage = ({ keychain }) => {
   }
 }
 
-// eslint-disable-next-line @exodus/export-default/named
 export default {
   id: 'unlockEncryptedStorage',
-  type: 'module',
   factory: createUnlockEncryptedStorage,
   dependencies: ['keychain'],
 }