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

package/src/features/remote-config/index.js

@@ -0,0 +1,28 @@
+import createRemoteConfig from '@exodus/config/remote'
+import EventEmitter from 'events/'
+
+import remoteConfigApiDefinition from './api'
+import remoteConfigPluginDefinition from './plugin'
+
+const remoteConfig = () => {
+  return {
+    id: 'remoteConfig',
+    definitions: [
+      {
+        definition: {
+          id: 'remoteConfig',
+          type: 'module',
+          factory: (deps) => {
+            const eventEmitter = new EventEmitter().setMaxListeners(Number.POSITIVE_INFINITY)
+            return createRemoteConfig({ eventEmitter, ...deps })
+          },
+          dependencies: ['fetch', 'freeze', 'config', 'logger'],
+        },
+      },
+      { definition: remoteConfigPluginDefinition },
+      { definition: remoteConfigApiDefinition },
+    ],
+  }
+}
+
+export default remoteConfig

package/src/features/remote-config/plugin.js

@@ -0,0 +1,20 @@
+const remoteConfigLifecyclePlugin = ({ remoteConfig, port }) => {
+  remoteConfig.on('sync', ({ current }) => port.emit('remote-config', current))
+
+  const onStart = () => {
+    remoteConfig.load()
+  }
+
+  const onUnlock = () => {
+    remoteConfig.sync()
+  }
+
+  return { onUnlock, onStart }
+}
+
+export default {
+  id: 'remoteConfigLifecyclePlugin',
+  type: 'plugin',
+  factory: remoteConfigLifecyclePlugin,
+  dependencies: ['remoteConfig', 'port'],
+}

package/src/features/wallet/api.js

@@ -0,0 +1,34 @@
+const createWalletApi = ({ wallet, application, passphraseCache }) => {
+  const restoreFromCurrentPhrase = async ({ passphrase } = {}) => {
+    if (!passphrase) passphrase = await passphraseCache.get()
+    const mnemonic = await application.getMnemonic({ passphrase })
+    await application.import({ passphrase, mnemonic })
+  }
+
+  return {
+    wallet: {
+      exists: () => wallet.exists(),
+      start: application.start,
+      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,
+      changeLockTimer: application.changeLockTimer,
+      restoreFromCurrentPhrase,
+      isLocked: () => wallet.isLocked(),
+    },
+  }
+}
+
+export default {
+  id: 'walletApi',
+  type: 'api',
+  factory: createWalletApi,
+  dependencies: ['wallet', 'application', 'passphraseCache'],
+}

package/src/features/wallet/index.js

@@ -0,0 +1,24 @@
+import walletDefinition from '@exodus/wallet/module'
+
+import walletApi from './api'
+import lockedAtomDefinition from './locked-atom'
+import restoreAtomDefinition from './restore-atom'
+import restorePluginDefinition from './restore-plugin'
+
+const wallet = () => {
+  return {
+    id: 'wallet',
+    definitions: [
+      {
+        definition: { type: 'module', ...walletDefinition },
+        writesAtoms: ['lockedAtom'],
+      },
+      { definition: lockedAtomDefinition },
+      { definition: restoreAtomDefinition },
+      { definition: restorePluginDefinition, writesAtoms: ['restoreAtom'] },
+      { definition: walletApi },
+    ],
+  }
+}
+
+export default wallet

package/src/features/wallet/locked-atom.js

@@ -0,0 +1,10 @@
+import { createInMemoryAtom } from '@exodus/atoms'
+
+const lockedAtomDefinition = {
+  id: 'lockedAtom',
+  type: 'atom',
+  factory: () => createInMemoryAtom({ defaultValue: true }),
+  dependencies: [],
+}
+
+export default lockedAtomDefinition

package/src/features/wallet/restore-atom.js

@@ -0,0 +1,10 @@
+import { createInMemoryAtom } from '@exodus/atoms'
+
+const restoreAtomDefinition = {
+  id: 'restoreAtom',
+  type: 'atom',
+  factory: () => createInMemoryAtom(),
+  dependencies: [],
+}
+
+export default restoreAtomDefinition

package/src/features/wallet/restore-plugin.js

@@ -0,0 +1,17 @@
+const restorePlugin = ({ restoreAtom }) => {
+  return {
+    onStart: async ({ isRestoring }) => {
+      await restoreAtom.set(!!isRestoring)
+    },
+    onAssetsSynced: async () => {
+      await restoreAtom.set(false)
+    },
+  }
+}
+
+export default {
+  id: 'restorePlugin',
+  type: 'plugin',
+  factory: restorePlugin,
+  dependencies: ['restoreAtom'],
+}

package/src/features/wallet-accounts/api.js

@@ -0,0 +1,16 @@
+const walletAccountsApi = ({ walletAccounts, enabledWalletAccountsAtom }) => ({
+  walletAccounts: {
+    create: walletAccounts.create,
+    update: walletAccounts.update,
+    disable: walletAccounts.disable,
+    enable: walletAccounts.enable,
+    getEnabled: enabledWalletAccountsAtom.get,
+  },
+})
+
+export default {
+  id: 'walletAccountsApi',
+  type: 'api',
+  factory: walletAccountsApi,
+  dependencies: ['walletAccounts', 'enabledWalletAccountsAtom'],
+}

package/src/features/wallet-accounts/index.js

@@ -0,0 +1,29 @@
+import {
+  enabledWalletAccountsAtomDefinition,
+  walletAccountsAtomDefinition,
+} from '@exodus/wallet-accounts/atoms'
+import walletAccountsDefinition from '@exodus/wallet-accounts/module'
+
+import walletAccountsApiDefinition from './api'
+import walletAccountsPluginDefinition from './plugin'
+
+const walletAccounts = () => {
+  return {
+    id: 'walletAccounts',
+    definitions: [
+      {
+        definition: walletAccountsDefinition,
+        writesAtoms: ['walletAccountsAtom'],
+      },
+      {
+        definition: walletAccountsAtomDefinition,
+        storage: { namespace: 'walletAccounts' },
+      },
+      { definition: enabledWalletAccountsAtomDefinition },
+      { definition: walletAccountsApiDefinition },
+      { definition: walletAccountsPluginDefinition },
+    ],
+  }
+}
+
+export default walletAccounts

package/src/features/wallet-accounts/plugin.js

@@ -0,0 +1,18 @@
+const walletAccountsPlugin = ({ walletAccounts }) => {
+  const onUnlock = async () => {
+    await walletAccounts.load()
+  }
+
+  const onClear = async () => {
+    await walletAccounts.clear()
+  }
+
+  return { onUnlock, onClear }
+}
+
+export default {
+  id: 'walletAccountsLifecyclePlugin',
+  type: 'plugin',
+  factory: walletAccountsPlugin,
+  dependencies: ['walletAccounts'],
+}

package/src/index.js

@@ -1,46 +1,130 @@
-import createIOC from './ioc'
+import abTesting from '@exodus/ab-testing'
+import addressProvider from '@exodus/address-provider'
+import apyRates from '@exodus/apy-rates'
+import { pick } from '@exodus/basic-utils'
+import connectedOrigins from '@exodus/connected-origins'
+import cryptoNews from '@exodus/crypto-news-monitor'
+import keychain from '@exodus/keychain'
+import kyc from '@exodus/kyc'
+import topMovers from '@exodus/top-movers-monitor'
+
 import createApi from './api'
+import attachAtoms from './atoms/attach'
+import { atomsToAttach } from './constants'
+import availableAssets from './features/available-assets'
+import balances from './features/balances'
+import blockchainMetadata from './features/blockchain-metadata'
+import enabledAssets from './features/enabled-assets'
+import featureFlags from './features/feature-flags'
+import fees from './features/fees'
+import fiatBalances from './features/fiat-balances'
+import geolocation from './features/geolocation'
+import locale from './features/locale'
+import marketHistory from './features/market-history'
+import nfts from './features/nfts'
+import pricing from './features/pricing'
+import rates from './features/rates'
+import remoteConfig from './features/remote-config'
+import wallet from './features/wallet'
+import walletAccounts from './features/wallet-accounts'
+import createIOC from './ioc'
+import attachPlugins from './plugins/attach'
 
 const createExodus = ({ adapters, config, port }) => {
   const ioc = createIOC({ adapters, config })
+  const { headless: headlessConfig, topMoversMonitor } = 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(fiatBalances())
+  ioc.use(remoteConfig())
+  ioc.use(geolocation())
+  ioc.use(marketHistory())
+  ioc.use(pricing())
+  ioc.use(fees())
+  ioc.use(rates())
+  ioc.use(apyRates())
+  ioc.use(featureFlags())
+  ioc.use(locale())
+  ioc.use(nfts())
+  ioc.use(kyc())
+  ioc.use(connectedOrigins())
+  ioc.use(abTesting())
+  ioc.use(cryptoNews())
+  ioc.use(topMovers({ config: topMoversMonitor }))
+  ioc.use(addressProvider({ config: config.addressProvider }))
+
+  ioc.register({ definition: { id: 'port', type: 'port', factory: () => port } })
 
   const resolve = () => {
     ioc.resolve()
 
     const { assetsModule, storage } = ioc.getByType('adapter')
 
-    const { application, unlockEncryptedStorage, walletAccounts } = ioc.getByType('module')
+    const { application, wallet, unlockEncryptedStorage } = ioc.getByType('module')
 
-    application.hook('start', () => {
-      port.emit('start')
+    application.hook('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'))
+
+    application.on('backup', () => port.emit('backup'))
+
+    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()
-      await walletAccounts.load()
     })
 
-    application.on('unlock', () => {
-      port.emit('unlock')
+    application.hook('clear', async () => {
+      await assetsModule.clear()
     })
 
-    application.hook('clear', async () => {
-      await Promise.all([
-        //
-        assetsModule.clear(),
-        walletAccounts.clear(),
-      ])
+    application.on('clear', () => port.emit('clear'))
 
-      port.emit('clear')
-    })
+    application.on('restart', (payload) => port.emit('restart', payload))
 
-    application.on('restart', (payload) => {
-      port.emit('restart', payload)
+    attachAtoms({
+      port,
+      application,
+      logger: ioc.get('createLogger')('attachAtoms'),
+      atoms: pick(ioc.getByType('atom'), atomsToAttach),
+      lifecycleEvents: headlessConfig?.attachAtomsLifecycleEvents,
     })
 
-    application.start()
+    attachPlugins({
+      application,
+      plugins: ioc.getByType('plugin'),
+      logger: ioc.get('createLogger')('attachPlugins'),
+    })
 
     return createApi({ ioc, port })
   }

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,25 @@
+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 }) => {
+  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, fn)
+      } 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/unlock-encrypted-storage.js

@@ -1,4 +1,4 @@
-import { EXODUS_KEY_IDS } from '@exodus/keychain'
+import { EXODUS_KEY_IDS } from '@exodus/keychain/module'
 
 const createUnlockEncryptedStorage = ({ keychain }) => {
   return async (encryptedStorage) => {