@exodus/headless 2.0.0-alpha.12 → 2.0.0-alpha.121

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/index.js

@@ -1,110 +1,117 @@
-import { pick } from '@exodus/basic-utils'
-import createIOC from './ioc'
-import createApi from './api'
-import {
-  createAccountStatesUpdateHandler,
-  createLoadWalletAccountsHandler,
-} from './utils/blockchain-metadata'
+import addressProvider from '@exodus/address-provider'
+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-monitors'
+import geolocation from '@exodus/geolocation'
+import keychain from '@exodus/keychain'
+import locale from '@exodus/locale'
+import pricing from '@exodus/pricing'
+import rates from '@exodus/rates-monitor'
+import remoteConfig from '@exodus/remote-config'
+import restoreProgressTracker from '@exodus/restore-progress-tracker'
+import wallet from '@exodus/wallet'
+import walletAccounts from '@exodus/wallet-accounts'
 
+import createApi from './api'
+import createIOC from './ioc'
+import attachMigrations from './migrations/attach'
 import attachPlugins from './plugins/attach'
-import attachAtoms from './atoms/attach'
-import { atomsToAttach } from './constants'
 
 const createExodus = ({ adapters, config, port }) => {
   const ioc = createIOC({ adapters, config })
-  const { headless: headlessConfig } = config
+
+  ioc.use(addressProvider({ config: config.addressProvider }))
+  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(rates())
+  ioc.use(remoteConfig())
+  ioc.use(restoreProgressTracker())
+  ioc.use(wallet())
+  ioc.use(walletAccounts())
+
+  ioc.register({ definition: { id: 'port', type: 'port', factory: () => port } })
 
   const resolve = () => {
     ioc.resolve()
 
-    const { assetsModule, storage } = ioc.getByType('adapter')
+    const { assetsModule, storage, fusion } = ioc.getByType('adapter')
 
-    const {
-      application,
-      blockchainMetadata,
-      enabledAssets,
-      remoteConfig,
-      unlockEncryptedStorage,
-      walletAccounts,
-    } = ioc.getByType('module')
-
-    const { marketHistory } = ioc.getByType('monitor')
-
-    const handleLoadWalletAccounts = createLoadWalletAccountsHandler({
-      blockchainMetadata,
-      port,
-      config,
-    })
+    const { lockedAtom } = ioc.getByType('atom')
 
-    const handleAccountStatesUpdate = createAccountStatesUpdateHandler({
-      blockchainMetadata,
-      port,
-      config,
-    })
+    const { application, wallet, unlockEncryptedStorage } = ioc.getByType('module')
 
-    blockchainMetadata.on('load-wallet-accounts', handleLoadWalletAccounts)
-    blockchainMetadata.on('tx-logs-update', (payload) => port.emit('tx-logs-update', payload))
-    blockchainMetadata.on('account-states-update', handleAccountStatesUpdate)
+    const { migrations } = ioc.getAll()
 
-    remoteConfig.on('sync', ({ current }) => port.emit('remote-config', current))
+    application.on('start', (payload) => port.emit('start', payload))
 
-    // TODO: migrate to marketHistoryAtom. Will be easier once it's on headless
-    marketHistory.on('market-history', (payload) => port.emit('market-history', payload))
+    application.on('load', (args) => port.emit('load', args))
 
-    application.hook('start', () => {
-      remoteConfig.load()
+    application.on('create', async ({ hasPassphraseSet }) => {
+      const isLocked = await wallet.isLocked()
 
-      port.emit('start')
+      port.emit('create', {
+        walletExists: true,
+        hasPassphraseSet,
+        isLocked,
+        isBackedUp: false,
+        isRestoring: false,
+      })
     })
 
-    application.hook('unlock', async () => {
-      if (typeof storage.unlock === 'function') unlockEncryptedStorage(storage)
+    application.on('unlock', () => port.emit('unlock'))
+
+    application.on('lock', () => port.emit('lock'))
 
-      remoteConfig.sync()
-      marketHistory.start()
+    application.on('backup', () => port.emit('backup'))
 
-      await assetsModule.load()
-      await walletAccounts.load()
-      await Promise.all([
-        //
-        blockchainMetadata.load(),
-        enabledAssets.load(),
-      ])
+    application.on('restore', () => port.emit('restore'))
+
+    application.on('restore-completed', () => {
+      port.emit('restore-completed')
     })
 
-    application.on('unlock', () => {
-      port.emit('unlock')
+    application.on('change-passphrase', () => port.emit('passphrase-changed'))
+
+    application.on('import', () => port.emit('import', { walletExists: true }))
+
+    application.hook('unlock', async () => {
+      if (typeof storage.unlock === 'function') unlockEncryptedStorage(storage)
     })
 
     application.hook('clear', async () => {
-      await Promise.all([
-        //
-        assetsModule.clear(),
-        walletAccounts.clear(),
-        blockchainMetadata.clear(),
-        enabledAssets.clear(),
-      ])
-
-      port.emit('clear')
+      await Promise.all([assetsModule.clear(), fusion.clearStorage()])
     })
 
-    application.on('restart', (payload) => {
-      port.emit('restart', payload)
-    })
+    application.on('clear', () => port.emit('clear'))
+
+    application.on('restart', (payload) => port.emit('restart', payload))
 
-    attachAtoms({
-      port,
+    attachMigrations({
+      migrations,
+      adapters,
       application,
-      logger: ioc.get('createLogger')('attachAtoms'),
-      atoms: pick(ioc.getByType('atom'), atomsToAttach),
-      lifecycleEvents: headlessConfig?.attachAtomsLifecycleEvents,
+      atoms: ioc.getByType('atom'),
+      modules: ioc.getByType('module'),
     })
 
-    attachPlugins({ application, plugins: ioc.getByType('plugin') })
-
-    application.start()
+    attachPlugins({
+      application,
+      plugins: ioc.getByType('plugin'),
+      logger: ioc.get('createLogger')('attachPlugins'),
+    })
 
-    return createApi({ ioc, port })
+    return createApi({ ioc, port, lockedAtom })
   }
 
   return { ...ioc, resolve }

package/src/ioc.js

@@ -1,30 +1,72 @@
 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 } = adapters
+  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 logger = createLogger('exodus:ioc')
-  const dependencies = createDependencies({ adapters, config })
   const preprocessors = [
     logify({ createLogger }),
-    namespaceConfig(),
+    performanceMonitorConfig?.enabled &&
+      performanceMonitor({
+        now: performance.now,
+        onAboveThreshold:
+          performance.onAboveThreshold ??
+          (({ id, method, duration }) =>
+            performanceLogger.log(`${id}.${method} took ${duration}ms`)),
+        config: performanceMonitorConfig,
+      }),
+    configPreprocessor(),
     alias(),
     // NOTE: order matters, this should come after `alias`
     namespaceStorage(),
-  ]
-  const definitions = preprocess({ dependencies, preprocessors })
-  const ioc = createIocContainer({ logger })
+    readOnlyAtoms({
+      logger: createLogger('exodus:read-only-atoms'),
+      warn: true,
+      ...readOnlyAtomsConfig,
+    }),
+    optional(),
+    devModeAtomsConfig && devModeAtoms(devModeAtomsConfig),
+  ].filter(Boolean)
+
+  const registerMultiple = (dependencies) => {
+    ioc.registerMultiple(preprocess({ dependencies, preprocessors }))
+  }
+
+  const register = (dependency) => {
+    registerMultiple([dependency])
+  }
+
+  const use = (module) => {
+    for (const { definition } of module.definitions) {
+      assert(definition.type, `ioc.use: "${definition.id}" is missing type field`)
+    }
+
+    registerMultiple(module.definitions)
+  }
 
-  ioc.registerMultiple(definitions)
+  registerMultiple(createDependencies({ adapters, config }))
 
-  return ioc
+  return { ...ioc, register, registerMultiple, use }
 }
 
 export default createIOC

package/src/migrations/attach.js

@@ -0,0 +1,60 @@
+import { deriveSyncKeys } from '../utils/fusion'
+
+const attachMigrations = ({ migrations = [], application, modules, adapters, ...deps }) => {
+  const { analytics, unlockEncryptedStorage, wallet } = modules
+  const { unsafeStorage, migrateableStorage, fusionKeysDeferred, migrateableFusion } = adapters
+
+  // Override encrypted storage with migrations own instance to make sure no modules reads from it before migrations ran
+  const migrationFlagsStorage = unsafeStorage.namespace('migrations')
+  const migrationAdapters = { ...adapters, storage: migrateableStorage, fusion: migrateableFusion }
+
+  const attachMigration = async (migration) => {
+    const { name, factory } = migration
+    const logger = adapters.createLogger(`exodus:migration:${name}`)
+
+    logger.log('running migration')
+
+    let success = false
+
+    try {
+      const start = performance.now()
+
+      await factory({ ...deps, adapters: migrationAdapters, modules, logger })
+
+      const time = performance.now() - start
+
+      logger.log(`migration successful in ${time.toFixed(2)}ms`)
+
+      await migrationFlagsStorage.set(name, true)
+
+      success = true
+    } catch (error) {
+      logger.log(`migration failed: ${error.stack}`)
+    } finally {
+      analytics.track({
+        event: 'ClientMigrationRun',
+        properties: { migrationId: name, success },
+        force: true,
+      })
+    }
+  }
+
+  application.hook('migrate', async () => {
+    await unlockEncryptedStorage(migrateableStorage)
+    if (fusionKeysDeferred) await deriveSyncKeys(wallet.seed).then(fusionKeysDeferred.resolve)
+
+    const migrationNames = migrations.map((migration) => migration.name)
+    const migrationFlags = await migrationFlagsStorage.batchGet(migrationNames)
+    const migrationsDiff = migrations.filter((v, k) => !migrationFlags[k])
+
+    for (const migration of migrationsDiff) {
+      await attachMigration(migration)
+    }
+  })
+
+  application.hook('clear', async () => {
+    await migrationFlagsStorage.clear()
+  })
+}
+
+export default attachMigrations

package/src/plugins/attach.js

@@ -1,17 +1,38 @@
-import { kebabCase, memoize } from 'lodash'
+import { LifecycleHook } from '../constants'
 
-// e.g. onUnlock -> unlock -> onUnlock, onChangePassphrase -> change-passphrase
-const getApplicationHookName = memoize((lifecycleMethod) =>
-  kebabCase(lifecycleMethod.replace(/^on/, ''))
+const LIFECYCLE_METHOD_TO_HOOK_NAME = Object.fromEntries(
+  Object.entries(LifecycleHook).map(([pascalCaseName, hookName]) => [
+    `on${pascalCaseName}`,
+    hookName,
+  ])
 )
 
-const attachPlugins = ({ plugins, application }) => {
+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
+  }
+
   Object.entries(plugins).forEach(([name, lifecycleMethods]) => {
     const entries = Object.entries(lifecycleMethods || {})
 
     for (const [lifecycleMethod, fn] of entries) {
-      const hookName = getApplicationHookName(lifecycleMethod)
-      application.hook(hookName, fn)
+      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}"`)
+      }
     }
   })
 }

package/src/plugins/index.js

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

package/src/plugins/log-lifecycle.js

@@ -9,6 +9,7 @@ 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/reporting.js

@@ -0,0 +1,27 @@
+import { zipObject } from 'lodash'
+
+const createReporting = ({ ioc, lockedAtom }) => {
+  const getReports = async () => {
+    if (await lockedAtom.get()) throw new Error('Unable to export when locked')
+
+    const nodes = ioc.getByType('report')
+    const reports = Object.values(nodes)
+
+    const resolvedReports = await Promise.allSettled(reports.map((report) => report.export()))
+
+    const namespaces = reports.map((report) => report.namespace)
+    const data = resolvedReports.map((outcome) =>
+      outcome.status === 'fulfilled' ? outcome.value : { error: outcome.reason }
+    )
+
+    return zipObject(namespaces, data)
+  }
+
+  return {
+    reporting: {
+      export: getReports,
+    },
+  }
+}
+
+export default createReporting

package/src/unlock-encrypted-storage.js

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

package/src/utils/fusion.js

@@ -0,0 +1,17 @@
+import { pick } from '@exodus/basic-utils'
+import HDKeySlip10 from '@exodus/hd-key-slip-10'
+import sodium from '@exodus/sodium-crypto'
+
+const EXODUS_PURPOSE = Number.parseInt(Buffer.from('exo').toString('hex'), '16')
+
+const EXO_2_PATH = `m/${EXODUS_PURPOSE}'/2'`
+
+const BIP43_PURPOSE_SYNC = `${EXO_2_PATH}/0'`
+
+export const deriveSyncKeys = async (seed) => {
+  const derived = HDKeySlip10.fromSeed(seed).derive(BIP43_PURPOSE_SYNC).key
+
+  const keys = await sodium.getSodiumKeysFromSeed(derived)
+
+  return pick(keys, ['box', 'sign', 'secret', 'derived'])
+}

package/src/atoms/attach.js

@@ -1,40 +0,0 @@
-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/dependencies/monitors.js

@@ -1,31 +0,0 @@
-import marketHistoryMonitorDefinition from '@exodus/market-history/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',
-        },
-      ],
-    },
-  ].map(withType('monitor'))
-
-export default createModuleDependencies

package/src/utils/blockchain-metadata.js

@@ -1,48 +0,0 @@
-import { mapValues } from '@exodus/basic-utils'
-
-const createAccountStatesTransformer = ({ serializePortPayloads, blockchainMetadata }) => {
-  return serializePortPayloads
-    ? (payload) =>
-        mapValues(payload, (byAsset, walletAccount) =>
-          mapValues(
-            byAsset,
-            (accountState, assetName) =>
-              blockchainMetadata.serializePayload({ walletAccount, assetName, accountState })
-                .accountState
-          )
-        )
-    : (payload) => payload
-}
-
-export function createAccountStatesUpdateHandler({
-  port,
-  blockchainMetadata,
-  config: { serializePortPayloads = false },
-}) {
-  const transform = createAccountStatesTransformer({ serializePortPayloads, blockchainMetadata })
-
-  return (payload) => {
-    port.emit('account-states-update', transform(payload))
-  }
-}
-
-export function createLoadWalletAccountsHandler({
-  port,
-  blockchainMetadata,
-  config: { serializePortPayloads = false },
-}) {
-  const transformAccountStates = createAccountStatesTransformer({
-    serializePortPayloads,
-    blockchainMetadata,
-  })
-
-  return async () => {
-    const [txLogs, accountStates] = await Promise.all([
-      blockchainMetadata.getLoadedTxLogs(),
-      blockchainMetadata.getLoadedAccountStates(),
-    ])
-
-    port.emit('tx-logs', txLogs)
-    port.emit('account-states', transformAccountStates(accountStates))
-  }
-}