@exodus/headless 2.0.0-alpha.67 → 2.0.0-alpha.7

package/src/dependencies/utils.js

@@ -2,6 +2,10 @@ 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,121 +1,68 @@
-import addressProvider from '@exodus/address-provider'
-import { pick } from '@exodus/basic-utils'
-import keychain from '@exodus/keychain'
-import marketHistory from '@exodus/market-history'
-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 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 geolocation from './features/geolocation'
-import locale from './features/locale'
-import nfts from './features/nfts'
-import pricing from './features/pricing'
-import rates from './features/rates'
-import remoteConfig from './features/remote-config'
 import createIOC from './ioc'
-import attachPlugins from './plugins/attach'
+import createApi from './api'
+import {
+  createAccountStatesUpdateHandler,
+  createLoadWalletAccountsHandler,
+} from './utils/blockchain-metadata'
 
 const createExodus = ({ adapters, config, port }) => {
   const ioc = createIOC({ adapters, config })
-  const { headless: headlessConfig } = 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(marketHistory())
-  ioc.use(pricing())
-  ioc.use(fees())
-  ioc.use(rates())
-  ioc.use(featureFlags())
-  ioc.use(locale())
-  ioc.use(nfts())
-  ioc.use(addressProvider({ config: config.addressProvider }))
-  ioc.use(restoreProgressTracker())
-
-  ioc.register({ definition: { id: 'port', type: 'port', factory: () => port } })
-
   const resolve = () => {
     ioc.resolve()
 
     const { assetsModule, storage } = 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))
+    const { application, unlockEncryptedStorage, blockchainMetadata, walletAccounts } =
+      ioc.getByType('module')
 
-    application.on('create', async ({ hasPassphraseSet }) => {
-      const isLocked = await wallet.isLocked()
-
-      port.emit('create', {
-        walletExists: true,
-        hasPassphraseSet,
-        isLocked,
-        isBackedUp: false,
-        isRestoring: false,
-      })
+    const handleLoadWalletAccounts = createLoadWalletAccountsHandler({
+      blockchainMetadata,
+      port,
+      config,
     })
-
-    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')
+    const handleAccountStatesUpdate = createAccountStatesUpdateHandler({
+      blockchainMetadata,
+      port,
+      config,
     })
 
-    application.on('change-passphrase', () => port.emit('passphrase-changed'))
+    blockchainMetadata.on('load-wallet-accounts', handleLoadWalletAccounts)
+    blockchainMetadata.on('tx-logs-update', (payload) => port.emit('tx-logs-update', payload))
+    blockchainMetadata.on('account-states-update', handleAccountStatesUpdate)
 
-    application.on('import', () => port.emit('import', { walletExists: true }))
+    application.hook('start', () => {
+      port.emit('start')
+    })
 
     application.hook('unlock', async () => {
       if (typeof storage.unlock === 'function') unlockEncryptedStorage(storage)
 
       await assetsModule.load()
+      await walletAccounts.load()
+      await blockchainMetadata.load()
     })
 
-    application.hook('clear', async () => {
-      await assetsModule.clear()
+    application.on('unlock', () => {
+      port.emit('unlock')
     })
 
-    application.on('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,
+    application.hook('clear', async () => {
+      await Promise.all([
+        //
+        assetsModule.clear(),
+        walletAccounts.clear(),
+        blockchainMetadata.clear(),
+      ])
+
+      port.emit('clear')
     })
 
-    attachPlugins({
-      application,
-      plugins: ioc.getByType('plugin'),
-      logger: ioc.get('createLogger')('attachPlugins'),
+    application.on('restart', (payload) => {
+      port.emit('restart', payload)
     })
 
+    application.start()
+
     return createApi({ ioc, port })
   }
 

package/src/ioc.js

@@ -1,56 +1,30 @@
 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 ioc = createIocContainer({ logger: createLogger('exodus:ioc') })
 
+  const logger = createLogger('exodus:ioc')
+  const dependencies = createDependencies({ adapters, config })
   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)] : []),
   ]
+  const definitions = preprocess({ dependencies, preprocessors })
+  const ioc = createIocContainer({ logger })
 
-  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 }))
+  ioc.registerMultiple(definitions)
 
-  return { ...ioc, register, registerMultiple, use }
+  return ioc
 }
 
 export default createIOC

package/src/unlock-encrypted-storage.js

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

package/src/utils/blockchain-metadata.js

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

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,38 +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,
-  })
-}
-
-// 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

@@ -1,38 +0,0 @@
-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',
-  Restart: 'restart',
-  Load: 'load',
-  Unload: 'unload',
-  Create: 'create',
-  Backup: 'backup',
-  Restore: 'restore',
-  RestoreCompleted: 'restore-completed',
-  AssetsSynced: 'assets-synced',
-  ChangePassphrase: 'change-passphrase',
-})

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

@@ -1,15 +0,0 @@
-import { availableAssetNamesAtomDefinition } from '@exodus/available-assets/atoms'
-import availableAssetsModuleDefinition from '@exodus/available-assets/module'
-
-const availableAssets = () => ({
-  id: 'availableAssets',
-  definitions: [
-    {
-      definition: { type: 'module', ...availableAssetsModuleDefinition },
-      writesAtoms: ['availableAssetNamesAtom'],
-    },
-    { definition: availableAssetNamesAtomDefinition },
-  ],
-})
-
-export default availableAssets

package/src/features/balances/index.js

@@ -1,14 +0,0 @@
-import { balancesAtomDefinition } from '@exodus/balances/atoms'
-import balancesDefinition from '@exodus/balances/module'
-
-const balances = () => {
-  return {
-    id: 'balances',
-    definitions: [
-      { definition: balancesDefinition, writesAtoms: ['balancesAtom'] },
-      { definition: balancesAtomDefinition },
-    ],
-  }
-}
-
-export default balances

package/src/features/blockchain-metadata/api.js

@@ -1,23 +0,0 @@
-const createBlockchainMetadataApi = ({ blockchainMetadata }) => ({
-  blockchainMetadata: {
-    getTxLog: blockchainMetadata.getTxLog,
-    getLoadedTxLogs: blockchainMetadata.getLoadedTxLogs,
-    updateTxs: blockchainMetadata.updateTxs,
-    overwriteTxs: blockchainMetadata.overwriteTxs,
-    clearTxs: blockchainMetadata.clearTxs,
-    removeTxs: blockchainMetadata.removeTxs,
-    getAccountState: blockchainMetadata.getAccountState,
-    getLoadedAccountStates: blockchainMetadata.getLoadedAccountStates,
-    updateAccountState: blockchainMetadata.updateAccountState,
-    removeAccountState: blockchainMetadata.removeAccountState,
-    batch: blockchainMetadata.batch,
-  },
-})
-
-// eslint-disable-next-line @exodus/export-default/named
-export default {
-  id: 'createBlockchainMetadataApi',
-  type: 'api',
-  factory: createBlockchainMetadataApi,
-  dependencies: ['blockchainMetadata'],
-}

package/src/features/blockchain-metadata/index.js

@@ -1,20 +0,0 @@
-import blockchainMetadataDefinition from '@exodus/blockchain-metadata/module'
-
-import blockchainMetadataApiDefinition from './api'
-import blockchainMetadataPluginDefinition from './plugin'
-
-const blockchainMetadata = () => {
-  return {
-    id: 'blockchainMetadata',
-    definitions: [
-      {
-        definition: blockchainMetadataDefinition,
-        storage: { namespace: ['blockchain', 'v1'] },
-      },
-      { definition: blockchainMetadataPluginDefinition },
-      { definition: blockchainMetadataApiDefinition },
-    ],
-  }
-}
-
-export default blockchainMetadata

package/src/features/blockchain-metadata/plugin.js

@@ -1,31 +0,0 @@
-import { createLoadWalletAccountsHandler } from './utils'
-
-const blockchainLifecyclePlugin = ({ blockchainMetadata, port }) => {
-  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)
-  )
-
-  const onUnlock = async () => {
-    await blockchainMetadata.load()
-  }
-
-  const onClear = async () => {
-    await blockchainMetadata.clear()
-  }
-
-  return { onUnlock, onClear }
-}
-
-// eslint-disable-next-line @exodus/export-default/named
-export default {
-  id: 'blockchainLifecyclePlugin',
-  type: 'plugin',
-  factory: blockchainLifecyclePlugin,
-  dependencies: ['blockchainMetadata', 'port'],
-}

package/src/features/blockchain-metadata/utils.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)
-  }
-}

package/src/features/enabled-assets/api.js

@@ -1,19 +0,0 @@
-const enabledAssetsApi = ({ enabledAssets, assetsModule }) => ({
-  assets: {
-    enable: enabledAssets.enable,
-    disable: enabledAssets.disable,
-    addAndEnableToken: async (...args) => {
-      const asset = await assetsModule.addToken(...args)
-      await enabledAssets.enable([asset.name])
-      return asset.name
-    },
-  },
-})
-
-// eslint-disable-next-line @exodus/export-default/named
-export default {
-  id: 'enabledAssetsApi',
-  type: 'api',
-  factory: enabledAssetsApi,
-  dependencies: ['enabledAssets', 'assetsModule'],
-}

package/src/features/enabled-assets/index.js

@@ -1,26 +0,0 @@
-import {
-  enabledAndDisabledAssetsAtomDefinition,
-  enabledAssetsAtomDefinition,
-} from '@exodus/enabled-assets/atoms'
-import enabledAssetsModuleDefinition from '@exodus/enabled-assets/module'
-
-import enabledAssetsApiDefinition from './api'
-import enabledAssetsPluginDefinition from './plugin'
-
-const enabledAssets = () => {
-  return {
-    id: 'enabledAssets',
-    definitions: [
-      { definition: enabledAssetsModuleDefinition, writesAtoms: ['enabledAndDisabledAssetsAtom'] },
-      {
-        definition: enabledAndDisabledAssetsAtomDefinition,
-        storage: { namespace: 'enabledAssets' },
-      },
-      { definition: enabledAssetsAtomDefinition },
-      { definition: enabledAssetsPluginDefinition },
-      { definition: enabledAssetsApiDefinition },
-    ],
-  }
-}
-
-export default enabledAssets

package/src/features/enabled-assets/plugin.js

@@ -1,19 +0,0 @@
-const createEnabledAssetsLifecyclePlugin = ({ enabledAssets }) => {
-  const onUnlock = async () => {
-    await enabledAssets.load()
-  }
-
-  const onClear = async () => {
-    await enabledAssets.clear()
-  }
-
-  return { onUnlock, onClear }
-}
-
-// eslint-disable-next-line @exodus/export-default/named
-export default {
-  id: 'enabledAssetsLifecyclePlugin',
-  type: 'plugin',
-  factory: createEnabledAssetsLifecyclePlugin,
-  dependencies: ['enabledAssets'],
-}

package/src/features/feature-flags/api.js

@@ -1,15 +0,0 @@
-const featureFlagsApi = ({ featureFlagAtoms }) => ({
-  features: {
-    set: (feature, value) => featureFlagAtoms[feature]?.set({ isOn: value }),
-    enable: (feature) => featureFlagAtoms[feature]?.set({ isOn: true }),
-    disable: (feature) => featureFlagAtoms[feature]?.set({ isOn: false }),
-  },
-})
-
-// eslint-disable-next-line @exodus/export-default/named
-export default {
-  id: 'featureFlagsApi',
-  type: 'api',
-  factory: featureFlagsApi,
-  dependencies: ['featureFlagAtoms'],
-}

package/src/features/feature-flags/index.js

@@ -1,37 +0,0 @@
-import {
-  featureFlagAtomsDefinition,
-  featureFlagsAtomDefinition,
-  remoteConfigFeatureFlagAtomsDefinition,
-} from '@exodus/feature-flags/atoms'
-import featureFlagsDefinition from '@exodus/feature-flags/module'
-
-import featureFlagsApiDefinition from './api'
-import featureFlagsPluginDefinition from './plugin'
-
-const featureFlags = () => {
-  return {
-    id: 'featureFlags',
-    definitions: [
-      {
-        definition: featureFlagsDefinition,
-        writesAtoms: ['featureFlagAtoms'],
-      },
-      {
-        definition: featureFlagAtomsDefinition,
-        storage: { namespace: 'featureFlags' },
-        aliases: [
-          {
-            implementationId: 'unsafeStorage',
-            interfaceId: 'storage',
-          },
-        ],
-      },
-      { definition: featureFlagsAtomDefinition },
-      { definition: remoteConfigFeatureFlagAtomsDefinition },
-      { definition: featureFlagsPluginDefinition },
-      { definition: featureFlagsApiDefinition },
-    ],
-  }
-}
-
-export default featureFlags