@exodus/headless 2.0.0-alpha.1 → 2.0.0-alpha.101

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

@@ -0,0 +1,38 @@
+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,
+  })
+}
+
+// eslint-disable-next-line @exodus/export-default/named
+export default {
+  id: 'baseAssetNamesToMonitorAtom',
+  type: 'atom',
+  factory: createBaseAssetNamesToMonitorAtom,
+  dependencies: ['assetsModule', 'availableAssetNamesAtom', 'enabledAssetsAtom', 'restoreAtom'],
+}

package/src/constants.js

@@ -0,0 +1,39 @@
+export const atomsToAttach = [
+  'abTestingAtom',
+  'apyRatesAtom',
+  'availableAssetNamesAtom',
+  'balancesAtom',
+  'connectedOriginsAtom',
+  'cryptoNewsAtom',
+  'currencyAtom',
+  'enabledWalletAccountsAtom',
+  'featureFlagsAtom',
+  'geolocationAtom',
+  'kycAtom',
+  'languageAtom',
+  'nftsConfigAtom',
+  'personalNotesAtom',
+  'referralsAtom',
+  'topMoversAtom',
+  'walletAccountsAtom',
+  'restoringAssetsAtom',
+]
+
+export const LifecycleHook = Object.freeze({
+  Lock: 'lock',
+  Unlock: 'unlock',
+  Clear: 'clear',
+  Import: 'import',
+  Migrate: 'migrate',
+  Start: 'start',
+  Stop: 'stop',
+  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,15 +1,5 @@
-import { createInMemoryAtom } from '@exodus/atoms'
-import { withType } from './utils'
+import baseAssetNamesToMonitorAtomDefinition from '../atoms/base-asset-names-to-monitor'
 
-const createAtomDependencies = () =>
-  [
-    {
-      definition: {
-        id: 'lockedAtom',
-        factory: () => createInMemoryAtom({ defaultValue: true }),
-        dependencies: [],
-      },
-    },
-  ].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,12 +1,11 @@
-import { createKeychain } from '@exodus/keychain'
-import walletDefinition from '@exodus/wallet/module'
 import createKeyIdentifierProvider from '@exodus/key-identifier-provider'
 import walletCompatibilityModesDefinition from '@exodus/wallet-compatibility-modes/module'
 
 import createApplication from '../application'
+import unlockEncryptedStorageDefinition from '../unlock-encrypted-storage'
 import { withType } from './utils'
 
-const createModuleDependencies = () =>
+const createModuleDependencies = ({ config }) =>
   [
     {
       definition: {
@@ -22,19 +21,10 @@ const createModuleDependencies = () =>
         dependencies: [],
       },
     },
-    {
-      definition: {
-        id: 'keychain',
-        factory: createKeychain,
-        dependencies: ['legacyPrivToPub'],
-      },
-    },
-    {
-      definition: walletDefinition,
-    },
     {
       definition: walletCompatibilityModesDefinition,
     },
+    { definition: unlockEncryptedStorageDefinition },
   ].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/index.js

@@ -1,35 +1,115 @@
-import createIOC from './ioc'
+import addressProvider from '@exodus/address-provider'
+import availableAssets from '@exodus/available-assets'
+import balances from '@exodus/balances'
+import { pick } from '@exodus/basic-utils'
+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 attachAtoms from './atoms/attach'
+import { atomsToAttach } from './constants'
+import createIOC from './ioc'
+import attachPlugins from './plugins/attach'
 
 const createExodus = ({ adapters, config, port }) => {
   const ioc = createIOC({ adapters, config })
 
+  ioc.use(wallet())
+  ioc.use(keychain(config.keychain))
+  ioc.use(walletAccounts())
+  ioc.use(blockchainMetadata())
+  ioc.use(availableAssets())
+  ioc.use(enabledAssets())
+  ioc.use(balances())
+  ioc.use(remoteConfig())
+  ioc.use(geolocation())
+  ioc.use(pricing())
+  ioc.use(fees())
+  ioc.use(rates())
+  ioc.use(featureFlags())
+  ioc.use(locale())
+  ioc.use(addressProvider({ config: config.addressProvider }))
+  ioc.use(restoreProgressTracker())
+
+  ioc.register({ definition: { id: 'port', type: 'port', factory: () => port } })
+
   const resolve = () => {
     ioc.resolve()
 
-    const { assetsModule } = ioc.getByType('adapter')
+    const { assetsModule, storage, fusion } = ioc.getByType('adapter')
+
+    const { application, wallet, unlockEncryptedStorage } = ioc.getByType('module')
+
+    application.on('start', (payload) => port.emit('start', payload))
+
+    application.on('load', (args) => port.emit('load', args))
+
+    application.on('create', async ({ hasPassphraseSet }) => {
+      const isLocked = await wallet.isLocked()
+
+      port.emit('create', {
+        walletExists: true,
+        hasPassphraseSet,
+        isLocked,
+        isBackedUp: false,
+        isRestoring: false,
+      })
+    })
+
+    application.on('unlock', () => port.emit('unlock'))
+
+    application.on('lock', () => port.emit('lock'))
 
-    const { application } = ioc.getByType('module')
+    application.on('backup', () => port.emit('backup'))
 
-    application.hook('start', () => {
-      port.emit('start')
+    application.on('restore', () => port.emit('restore'))
+
+    application.on('restore-completed', () => {
+      port.emit('restore-completed')
     })
 
+    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)
+
       await assetsModule.load()
     })
 
     application.hook('clear', async () => {
-      await Promise.all([assetsModule.clear()])
+      await Promise.all([assetsModule.clear(), fusion.clearStorage()])
     })
 
-    application.on('restart', () => {
-      port.emit('restart')
+    application.on('clear', () => port.emit('clear'))
+
+    application.on('restart', (payload) => port.emit('restart', payload))
+
+    attachAtoms({
+      port,
+      application,
+      atoms: pick(ioc.getByType('atom'), atomsToAttach),
     })
 
-    application.start()
+    attachPlugins({
+      application,
+      plugins: ioc.getByType('plugin'),
+      logger: ioc.get('createLogger')('attachPlugins'),
+    })
 
-    return createApi({ ioc })
+    return createApi({ ioc, port })
   }
 
   return { ...ioc, resolve }

package/src/ioc.js

@@ -1,23 +1,56 @@
 import createIocContainer from '@exodus/dependency-injection'
 import preprocess from '@exodus/dependency-preprocessors'
 import alias from '@exodus/dependency-preprocessors/src/preprocessors/alias'
+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 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 { readOnlyAtoms: readOnlyAtomsConfig, devModeAtoms: devModeAtomsConfig } = config.ioc ?? {}
 
-  const logger = createLogger('exodus:ioc')
-  const dependencies = createDependencies({ adapters, config })
-  const preprocessors = [logify({ createLogger }), namespaceConfig(), alias()]
-  const definitions = preprocess({ dependencies, preprocessors })
-  const ioc = createIocContainer({ logger })
+  const ioc = createIocContainer({ logger: createLogger('exodus:ioc') })
 
-  ioc.registerMultiple(definitions)
+  const preprocessors = [
+    logify({ createLogger }),
+    namespaceConfig(),
+    alias(),
+    // NOTE: order matters, this should come after `alias`
+    namespaceStorage(),
+    readOnlyAtoms({
+      logger: createLogger('exodus:read-only-atoms'),
+      warn: true,
+      ...readOnlyAtomsConfig,
+    }),
+    optional(),
+    ...(devModeAtomsConfig ? [devModeAtoms(devModeAtomsConfig)] : []),
+  ]
 
-  return ioc
+  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)
+  }
+
+  registerMultiple(createDependencies({ adapters, config }))
+
+  return { ...ioc, register, registerMultiple, use }
 }
 
 export default createIOC

package/src/plugins/attach.js

@@ -0,0 +1,36 @@
+import { LifecycleHook } from '../constants'
+
+const LIFECYCLE_METHOD_TO_HOOK_NAME = Object.fromEntries(
+  Object.entries(LifecycleHook).map(([pascalCaseName, hookName]) => [
+    `on${pascalCaseName}`,
+    hookName,
+  ])
+)
+
+const attachPlugins = ({ plugins, application, logger }) => {
+  const timeFn =
+    (fn, name) =>
+    async (...args) => {
+      const start = Date.now()
+      try {
+        return await fn(...args)
+      } finally {
+        logger.debug(name, `${Date.now() - start}ms`)
+      }
+    }
+
+  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}"`)
+      }
+    }
+  })
+}
+
+export default attachPlugins

package/src/plugins/index.js

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

package/src/plugins/log-lifecycle.js

@@ -0,0 +1,26 @@
+const logLifecycle = {
+  id: 'logLifecyclePlugin',
+  type: 'plugin',
+  factory: ({ logger }) => {
+    return {
+      onLock: () => logger.debug('onLock'),
+      onUnlock: () => logger.debug('onUnlock'),
+      onClear: () => logger.debug('onClear'),
+      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'),
+      onBackup: () => logger.debug('onBackup'),
+      onRestore: () => logger.debug('onRestore'),
+      onRestoreCompleted: () => logger.debug('onRestoreCompleted'),
+      onAssetsSynced: () => logger.debug('onAssetsSynced'),
+      onChangePassphrase: () => logger.debug('onChangePassphrase'),
+    }
+  },
+  dependencies: ['logger'],
+}
+
+export default logLifecycle

package/src/reporting.js

@@ -0,0 +1,25 @@
+import { zipObject } from 'lodash'
+
+const createReporting = ({ ioc }) => {
+  const getReports = async () => {
+    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

@@ -0,0 +1,21 @@
+import { EXODUS_KEY_IDS } from '@exodus/keychain/module'
+
+const createUnlockEncryptedStorage = ({ keychain }) => {
+  return async (encryptedStorage) => {
+    // should the key id be part of a `config` dep?
+    const sodiumEncryptor = keychain.createSodiumEncryptor(EXODUS_KEY_IDS.WALLET_INFO)
+
+    await encryptedStorage.unlock({
+      encrypt: (data) => sodiumEncryptor.encryptSecretBox({ data }),
+      decrypt: (data) => sodiumEncryptor.decryptSecretBox({ data }),
+    })
+  }
+}
+
+// eslint-disable-next-line @exodus/export-default/named
+export default {
+  id: 'unlockEncryptedStorage',
+  type: 'module',
+  factory: createUnlockEncryptedStorage,
+  dependencies: ['keychain'],
+}