@exodus/headless 2.0.0-alpha.39 → 2.0.0-alpha.4

package/src/index.js

@@ -1,121 +1,22 @@
-import { pick } from '@exodus/basic-utils'
-
-import createApi from './api'
-import attachAtoms from './atoms/attach'
-import { atomsToAttach } from './constants'
 import createIOC from './ioc'
-import attachPlugins from './plugins/attach'
-import { createLoadWalletAccountsHandler } from './utils/blockchain-metadata'
+import createApi from './api'
 
 const createExodus = ({ adapters, config, port }) => {
   const ioc = createIOC({ adapters, config })
-  const { headless: headlessConfig } = config
 
   const resolve = () => {
     ioc.resolve()
 
-    const { assetsModule, storage } = ioc.getByType('adapter')
-
-    const { languageAtom } = ioc.getByType('atom')
-
-    const {
-      application,
-      blockchainMetadata,
-      connectedOrigins,
-      enabledAssets,
-      featureFlags,
-      kyc,
-      nfts,
-      personalNotes,
-      referrals,
-      remoteConfig,
-      unlockEncryptedStorage,
-      walletAccounts,
-    } = ioc.getByType('module')
-
-    const {
-      apyRatesMonitor,
-      cryptoNewsMonitor,
-      feeMonitors,
-      geolocationMonitor,
-      marketHistory,
-      nftsMonitor,
-      ratesMonitor,
-      topMoversMonitor,
-    } = 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)
-    )
-
-    feeMonitors.on('fees-load', () => port.emit('fees-load', feeMonitors.getAllFeeData()))
-    feeMonitors.on('fees-update', (payload) => port.emit('fees-update', payload))
-
-    remoteConfig.on('sync', ({ current }) => port.emit('remote-config', current))
+    const { assetsModule } = ioc.getByType('adapter')
 
-    // TODO: migrate to marketHistoryAtom. Will be easier once it's on headless
-    marketHistory.on('market-history', (payload) => port.emit('market-history', payload))
-    marketHistory.on('market-history-new-assets', (payload) =>
-      port.emit('market-history-new-assets', payload)
-    )
+    const { application } = ioc.getByType('module')
 
-    // TODO: migrate to ratesAtom. Will be easier once it's on headless
-    ratesMonitor.on('rates', (payload) => port.emit('rates', payload))
-
-    nftsMonitor.on('nfts', (data) => port.emit('nfts', data))
-    nftsMonitor.on('nfts-txs', (data) => port.emit('nfts-txs', data))
-
-    application.hook('start', (payload) => {
-      remoteConfig.load()
-      featureFlags.load()
-      geolocationMonitor.start()
-
-      port.emit('start', payload)
+    application.hook('start', () => {
+      port.emit('start')
     })
 
     application.hook('unlock', async () => {
-      if (typeof storage.unlock === 'function') unlockEncryptedStorage(storage)
-
-      remoteConfig.sync()
-      marketHistory.start()
-      ratesMonitor.start()
-      feeMonitors.start()
-      apyRatesMonitor.start()
-      nftsMonitor.start()
-
       await assetsModule.load()
-      await connectedOrigins.load()
-      await walletAccounts.load()
-      await Promise.all([
-        //
-        blockchainMetadata.load(),
-        enabledAssets.load(),
-      ])
-
-      featureFlagAtoms.referrals?.get().then(({ isOn }) => {
-        if (!isOn) return
-        kyc.load()
-        referrals.load()
-      })
-
-      featureFlagAtoms.topMovers?.get().then(({ isOn }) => {
-        if (!isOn) return
-        topMoversMonitor.start()
-      })
-
-      featureFlagAtoms.cryptoNews?.get().then(({ isOn }) => {
-        if (!isOn) return
-        cryptoNewsMonitor.start()
-      })
     })
 
     application.on('unlock', () => {
@@ -123,37 +24,14 @@ const createExodus = ({ adapters, config, port }) => {
     })
 
     application.hook('clear', async () => {
-      await Promise.all([
-        //
-        assetsModule.clear(),
-        walletAccounts.clear(),
-        blockchainMetadata.clear(),
-        enabledAssets.clear(),
-        connectedOrigins.clear(),
-        featureFlags.clear(),
-        languageAtom.set(undefined),
-      ])
-
-      // TEMP: dont wait to clear as encrypted storage is not yet unlocked
-      personalNotes.clear()
-      nfts.clear()
-
-      port.emit('clear')
+      await Promise.all([assetsModule.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, port })
   }

package/src/ioc.js

@@ -1,48 +1,23 @@
 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 createDependencies from './dependencies'
 
 const createIOC = ({ adapters, config }) => {
   const { createLogger } = adapters
-  const { readOnlyAtoms: readOnlyAtomsConfig, devModeAtoms: devModeAtomsConfig } = config.ioc ?? {}
 
-  const ioc = createIocContainer({ logger: createLogger('exodus: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 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)] : []),
-  ]
+  ioc.registerMultiple(definitions)
 
-  const registerMultiple = (dependencies) => {
-    ioc.registerMultiple(preprocess({ dependencies, preprocessors }))
-  }
-
-  const register = (dependency) => {
-    registerMultiple([dependency])
-  }
-
-  registerMultiple(dependencies)
-
-  return { ...ioc, register, registerMultiple }
+  return ioc
 }
 
 export default createIOC

package/src/atoms/attach.js

@@ -1,31 +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 })
-    })
-  )
-
-  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/atoms/base-asset-names-to-monitor.js

@@ -1,36 +0,0 @@
-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,
-  })
-}
-
-export default {
-  id: 'baseAssetNamesToMonitorAtom',
-  factory: createBaseAssetNamesToMonitorAtom,
-  dependencies: ['assetsModule', 'availableAssetNamesAtom', 'enabledAssetsAtom', 'restoreAtom'],
-}

package/src/atoms/non-dust-balance-asset-names-atom.js

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

package/src/atoms/restore.js

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

package/src/constants.js

@@ -1,18 +0,0 @@
-export const atomsToAttach = [
-  'apyRatesAtom',
-  'availableAssetNamesAtom',
-  'balancesAtom',
-  'connectedOriginsAtom',
-  'cryptoNewsAtom',
-  'currencyAtom',
-  'enabledWalletAccountsAtom',
-  'featureFlagsAtom',
-  'geolocationAtom',
-  'kycAtom',
-  'languageAtom',
-  'nftsConfigAtom',
-  'personalNotesAtom',
-  'referralsAtom',
-  'topMoversAtom',
-  'walletAccountsAtom',
-]

package/src/dependencies/atom-collections.js

@@ -1,25 +0,0 @@
-import {
-  featureFlagAtomsDefinition,
-  remoteConfigFeatureFlagAtomsDefinition,
-} from '@exodus/feature-flags/atoms'
-
-import { withType } from './utils'
-
-const createAtomCollectionDependencies = () =>
-  [
-    {
-      definition: remoteConfigFeatureFlagAtomsDefinition,
-    },
-    {
-      definition: featureFlagAtomsDefinition,
-      storage: { namespace: 'featureFlags' },
-      aliases: [
-        {
-          implementationId: 'unsafeStorage',
-          interfaceId: 'storage',
-        },
-      ],
-    },
-  ].map(withType('atom-collection'))
-
-export default createAtomCollectionDependencies

package/src/dependencies/monitors.js

@@ -1,66 +0,0 @@
-import apyRatesMonitorDefinition from '@exodus/apy-rates/monitor'
-import cryptoNewsMonitorDefinition from '@exodus/crypto-news-monitor/monitor'
-import feeMonitorsDefinition from '@exodus/fee-monitors/monitor'
-import geolocationMonitorDefinition from '@exodus/geolocation/monitor'
-import marketHistoryMonitorDefinition from '@exodus/market-history/module'
-import nftsMonitorDefinition from '@exodus/nfts/monitor'
-import ratesMonitorDefinition from '@exodus/rates-monitor/module'
-import localTopMoversMonitorDefinition from '@exodus/top-movers-monitor/monitor/local'
-import remoteTopMoversMonitorDefinition from '@exodus/top-movers-monitor/monitor/remote'
-
-import { withType } from './utils'
-
-const createMonitorDependencies = ({ config }) =>
-  [
-    {
-      definition: geolocationMonitorDefinition,
-      writesAtoms: ['geolocationAtom'],
-    },
-    {
-      definition: marketHistoryMonitorDefinition,
-      storage: { namespace: 'marketHistory' },
-      aliases: [
-        {
-          implementationId: 'unsafeStorage',
-          interfaceId: 'storage',
-        },
-        {
-          implementationId: 'marketHistoryClearCacheAtom',
-          interfaceId: 'clearCacheAtom',
-        },
-        {
-          implementationId: 'remoteConfigClearMarketHistoryCacheAtom',
-          interfaceId: 'remoteConfigClearCacheAtom',
-        },
-        {
-          implementationId: 'marketHistoryRefreshIntervalAtom',
-          interfaceId: 'remoteConfigRefreshIntervalAtom',
-        },
-      ],
-    },
-    { definition: feeMonitorsDefinition },
-    {
-      definition: ratesMonitorDefinition,
-      writesAtoms: ['ratesAtom'],
-    },
-    {
-      definition: config.topMoversMonitor.computeLocally
-        ? localTopMoversMonitorDefinition
-        : remoteTopMoversMonitorDefinition,
-      writesAtoms: ['topMoversAtom'],
-    },
-    {
-      definition: cryptoNewsMonitorDefinition,
-      writesAtoms: ['cryptoNewsAtom'],
-    },
-    {
-      definition: apyRatesMonitorDefinition,
-      writesAtoms: ['apyRatesAtom'],
-    },
-    {
-      definition: nftsMonitorDefinition,
-      writesAtoms: ['nftsCacheAtom'],
-    },
-  ].map(withType('monitor'))
-
-export default createMonitorDependencies

package/src/dependencies/plugins.js

@@ -1,7 +0,0 @@
-import plugins from '../plugins'
-import { withType } from './utils'
-
-const createPluginDependencies = () =>
-  plugins.map((definition) => ({ definition })).map(withType('plugin'))
-
-export default createPluginDependencies

package/src/plugins/attach.js

@@ -1,19 +0,0 @@
-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

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

package/src/plugins/log-lifecycle.js

@@ -1,25 +0,0 @@
-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/plugins/restore.js

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

package/src/unlock-encrypted-storage.js

@@ -1,19 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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)
-  }
-}