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

package/src/index.js

@@ -1,35 +1,119 @@
+import { pick } from '@exodus/basic-utils'
 import createIOC from './ioc'
 import createApi from './api'
+import { 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 })
+  const { headless: headlessConfig } = config
 
   const resolve = () => {
     ioc.resolve()
 
-    const { assetsModule } = ioc.getByType('adapter')
+    const { assetsModule, storage } = ioc.getByType('adapter')
+
+    const {
+      application,
+      blockchainMetadata,
+      enabledAssets,
+      featureFlags,
+      kyc,
+      referrals,
+      remoteConfig,
+      unlockEncryptedStorage,
+      walletAccounts,
+    } = ioc.getByType('module')
+
+    const { geolocationMonitor, marketHistory, ratesMonitor } = ioc.getByType('monitor')
+
+    const { featureFlagAtoms } = ioc.getByType('atom-collection')
+
+    const handleLoadWalletAccounts = createLoadWalletAccountsHandler({
+      blockchainMetadata,
+      port,
+    })
+
+    blockchainMetadata.on('load-wallet-accounts', handleLoadWalletAccounts)
+    blockchainMetadata.on('tx-logs-update', (payload) => port.emit('tx-logs-update', payload))
+    blockchainMetadata.on('account-states-update', (payload) =>
+      port.emit('account-states-update', payload)
+    )
+
+    remoteConfig.on('sync', ({ current }) => port.emit('remote-config', current))
 
-    const { application } = ioc.getByType('module')
+    // TODO: migrate to marketHistoryAtom. Will be easier once it's on headless
+    marketHistory.on('market-history', (payload) => port.emit('market-history', payload))
+
+    // TODO: migrate to ratesAtom. Will be easier once it's on headless
+    ratesMonitor.on('rates', (payload) => port.emit('rates', payload))
 
     application.hook('start', () => {
+      remoteConfig.load()
+      featureFlags.load()
+
       port.emit('start')
     })
 
     application.hook('unlock', async () => {
+      if (typeof storage.unlock === 'function') unlockEncryptedStorage(storage)
+
+      remoteConfig.sync()
+      marketHistory.start()
+      ratesMonitor.start()
+      geolocationMonitor.start()
+
       await assetsModule.load()
+      await walletAccounts.load()
+      await Promise.all([
+        //
+        blockchainMetadata.load(),
+        enabledAssets.load(),
+      ])
+
+      featureFlagAtoms.referrals?.get().then(({ isOn }) => {
+        if (!isOn) return
+        kyc.load()
+        referrals.load()
+      })
+    })
+
+    application.on('unlock', () => {
+      port.emit('unlock')
     })
 
     application.hook('clear', async () => {
-      await Promise.all([assetsModule.clear()])
+      await Promise.all([
+        //
+        assetsModule.clear(),
+        walletAccounts.clear(),
+        blockchainMetadata.clear(),
+        enabledAssets.clear(),
+      ])
+
+      port.emit('clear')
     })
 
     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,
+    })
+
+    attachPlugins({ application, plugins: ioc.getByType('plugin') })
+
     application.start()
 
-    return createApi({ ioc })
+    return createApi({ ioc, port })
   }
 
   return { ...ioc, resolve }

package/src/ioc.js

@@ -3,15 +3,29 @@ import preprocess from '@exodus/dependency-preprocessors'
 import alias from '@exodus/dependency-preprocessors/src/preprocessors/alias'
 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 readOnlyAtoms from '@exodus/dependency-preprocessors/src/preprocessors/read-only-atoms'
 
 import createDependencies from './dependencies'
 
 const createIOC = ({ adapters, config }) => {
   const { createLogger } = adapters
+  const { readOnlyAtoms: readOnlyAtomsConfig } = config.ioc ?? {}
 
   const logger = createLogger('exodus:ioc')
   const dependencies = createDependencies({ adapters, config })
-  const preprocessors = [logify({ createLogger }), namespaceConfig(), alias()]
+  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,
+    }),
+  ]
   const definitions = preprocess({ dependencies, preprocessors })
   const ioc = createIocContainer({ logger })
 

package/src/plugins/attach.js

@@ -0,0 +1,19 @@
+import { kebabCase, memoize } from 'lodash'
+
+// e.g. onUnlock -> unlock -> onUnlock, onChangePassphrase -> change-passphrase
+const getApplicationHookName = memoize((lifecycleMethod) =>
+  kebabCase(lifecycleMethod.replace(/^on/, ''))
+)
+
+const attachPlugins = ({ plugins, application }) => {
+  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)
+    }
+  })
+}
+
+export default attachPlugins

package/src/plugins/index.js

@@ -0,0 +1,3 @@
+import logLifecyclePlugin from './log-lifecycle'
+
+export default [logLifecyclePlugin]

package/src/plugins/log-lifecycle.js

@@ -0,0 +1,25 @@
+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'),
+      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

@@ -0,0 +1,19 @@
+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 }),
+    })
+  }
+}
+
+export default {
+  id: 'unlockEncryptedStorage',
+  factory: createUnlockEncryptedStorage,
+  dependencies: ['keychain'],
+}

package/src/utils/blockchain-metadata.js

@@ -0,0 +1,11 @@
+export function createLoadWalletAccountsHandler({ port, blockchainMetadata }) {
+  return async () => {
+    const [txLogs, accountStates] = await Promise.all([
+      blockchainMetadata.getLoadedTxLogs(),
+      blockchainMetadata.getLoadedAccountStates(),
+    ])
+
+    port.emit('tx-logs', txLogs)
+    port.emit('account-states', accountStates)
+  }
+}