@exodus/headless 2.0.0-alpha.48 → 2.0.0-alpha.5

package/src/api.js

@@ -1,36 +1,35 @@
 import { validateMnemonic as isMnemonicValid } from 'bip39'
 
 const createApi = ({ ioc, port }) => {
-  const apis = ioc.getByType('api')
+  const { passphraseCache } = ioc.getByType('adapter')
 
-  const { assetsModule } = ioc.getByType('adapter')
-
-  const { enabledAssets, remoteConfig } = ioc.getByType('module')
-
-  const { feeMonitors, nftsMonitor } = ioc.getByType('monitor')
-
-  // TODO: do this on 'unload'
-  const stop = () => {
-    remoteConfig.stop()
-    feeMonitors.stop()
-    nftsMonitor?.stop()
-  }
+  const { application, wallet } = ioc.getByType('module')
 
   return {
-    ...Object.assign({}, ...Object.values(apis)),
-    assets: {
-      enable: enabledAssets.enable,
-      disable: enabledAssets.disable,
-      addAndEnableToken: async (...args) => {
-        const asset = await assetsModule.addToken(...args)
-        await enabledAssets.enable([asset.name])
-        return asset.name
+    wallet: {
+      exists: () => wallet.exists(),
+      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,
+      restoreFromCurrentPhrase: async ({ passphrase } = {}) => {
+        if (!passphrase) passphrase = await passphraseCache.get()
+        const mnemonic = await application.getMnemonic({ passphrase })
+
+        await application.import({ passphrase, mnemonic })
       },
+      changeLockTimer: application.changeLockTimer,
+      isLocked: () => wallet.isLocked(),
     },
     isMnemonicValid,
     subscribe: port.subscribe.bind(port),
     unsubscribe: port.unsubscribe.bind(port),
-    stop,
   }
 }
 

package/src/application.js

@@ -3,8 +3,6 @@
 import ExodusModule from '@exodus/module'
 import assert from 'minimalistic-assert'
 
-import { LifecycleHook as Hook } from './constants'
-
 // Because we are forced to restart wallet after deleting/importing, we need to store certain flags to persist state between executions
 
 // Triggers deletetion logic when wallet starts.
@@ -19,7 +17,22 @@ const IMPORT_FLAG = 'importFlag'
 // Set as true on import method is called, and set to false after restore is completed
 const RESTORE_FLAG = 'restoreFlag'
 
-const HOOKS = new Set(Object.values(Hook))
+const HOOKS = Object.freeze({
+  lock: 'lock',
+  unlock: 'unlock',
+  clear: 'clear',
+  import: 'import',
+  migrate: 'migrate',
+  start: 'start',
+  load: 'load',
+  unload: 'unload',
+  create: 'create',
+  backup: 'backup',
+  restore: 'restore',
+  'restore-completed': 'restore-completed',
+  'assets-synced': 'assets-synced',
+  'change-passphrase': 'change-passphrase',
+})
 
 class Application extends ExodusModule {
   #hooks = {}
@@ -37,7 +50,6 @@ class Application extends ExodusModule {
     this.#storage = unsafeStorage.namespace('flags')
 
     this.#applicationStarted = new Promise((resolve) => (this.#resolveStart = resolve))
-    this.setMaxListeners(Number.POSITIVE_INFINITY)
   }
 
   start = async () => {
@@ -56,26 +68,12 @@ class Application extends ExodusModule {
     const walletExists = await this.#wallet.exists()
 
     if (isImporting || !walletExists) {
-      await this.fire(Hook.Clear)
+      await this.fire(HOOKS.clear)
     }
 
-    if (isImporting) await this.fire(Hook.Import)
-
-    const [hasPassphraseSet, isLocked, isBackedUp, isRestoring] = await Promise.all([
-      this.#wallet.hasPassphraseSet(),
-      this.#wallet.isLocked(),
-      this.#wallet.isBackedUp(),
-      this.isRestoring(),
-    ])
-
-    await this.fire(Hook.Start, {
-      walletExists,
-      hasPassphraseSet,
-      isLocked,
-      isBackedUp,
-      isRestoring,
-    })
+    if (isImporting) await this.fire(HOOKS.import)
 
+    await this.fire(HOOKS.start)
     await this.#autoUnlock()
 
     const locked = await this.#wallet.isLocked()
@@ -95,7 +93,7 @@ class Application extends ExodusModule {
       this.isRestoring(),
     ])
 
-    await this.fire(Hook.Load, {
+    await this.fire(HOOKS.load, {
       walletExists,
       hasPassphraseSet,
       isLocked,
@@ -106,11 +104,11 @@ class Application extends ExodusModule {
   unload = async () => {
     await this.#applicationStarted
     await this.#passphraseCache.scheduleClear()
-    await this.fire(Hook.Unload)
+    await this.fire(HOOKS.unload)
   }
 
   hook = (hookName, listener) => {
-    assert(HOOKS.has(hookName), `no such hook: ${hookName}`)
+    assert(HOOKS[hookName], `no such hook: ${hookName}`)
 
     if (!this.#hooks[hookName]) {
       this.#hooks[hookName] = []
@@ -120,7 +118,7 @@ class Application extends ExodusModule {
   }
 
   fire = async (hookName, params) => {
-    assert(HOOKS.has(hookName), `no such hook: ${hookName}`)
+    assert(HOOKS[hookName], `no such hook: ${hookName}`)
     this._logger.debug('firing hooks', hookName)
 
     const hooks = this.#hooks[hookName] || []
@@ -138,15 +136,7 @@ class Application extends ExodusModule {
     await this.#applicationStarted
     await this.#wallet.create(opts)
 
-    const isLocked = await this.#wallet.isLocked()
-
-    await this.fire(Hook.Create, {
-      hasPassphraseSet: !!opts?.passphrase,
-      isBackedUp: false,
-      isLocked,
-      isRestoring: false,
-      walletExists: true,
-    })
+    await this.fire(HOOKS.create, { hasPassphraseSet: !!opts?.passphrase })
   }
 
   import = async (opts) => {
@@ -167,7 +157,7 @@ class Application extends ExodusModule {
 
       this.emit('restart', { reason: 'import' })
     } else {
-      await this.fire(Hook.Import)
+      await this.fire(HOOKS.import)
 
       this._logger.log('wallet imported')
     }
@@ -177,7 +167,7 @@ class Application extends ExodusModule {
 
   setBackedUp = async () => {
     await this.#wallet.setBackedUp()
-    await this.fire(Hook.Backup)
+    await this.fire(HOOKS.backup)
   }
 
   lock = async (opts) => {
@@ -186,7 +176,7 @@ class Application extends ExodusModule {
     await this.#applicationStarted
     await this.#wallet.lock(opts)
     await this.#passphraseCache.clear()
-    await this.fire(Hook.Lock)
+    await this.fire(HOOKS.lock)
 
     this._logger.log('locked')
   }
@@ -195,13 +185,13 @@ class Application extends ExodusModule {
     const isRestoring = await this.isRestoring()
 
     if (isRestoring) {
-      await this.fire(Hook.Restore)
+      await this.fire(HOOKS.restore)
       await this.#storage.delete(RESTORE_FLAG)
       await this.setBackedUp()
-      await this.fire(Hook.RestoreCompleted)
+      await this.fire(HOOKS['restore-completed'])
     }
 
-    this.fire(Hook.AssetsSynced)
+    this.fire(HOOKS['assets-synced'])
   }
 
   #autoUnlock = async () => {
@@ -214,7 +204,7 @@ class Application extends ExodusModule {
       this._logger.log('unlocking with cache')
 
       await this.#wallet.unlock({ passphrase })
-      await this.fire(Hook.Unlock)
+      await this.fire(HOOKS.unlock)
 
       this.#restoreIfNeeded()
 
@@ -230,8 +220,8 @@ class Application extends ExodusModule {
     await this.#applicationStarted
     await this.#wallet.unlock({ passphrase })
 
-    await this.fire(Hook.Migrate)
-    await this.fire(Hook.Unlock)
+    await this.fire(HOOKS.migrate)
+    await this.fire(HOOKS.unlock)
 
     this.#restoreIfNeeded()
 
@@ -246,7 +236,7 @@ class Application extends ExodusModule {
     await this.#applicationStarted
     await this.#wallet.changePassphrase({ currentPassphrase, newPassphrase })
     await this.#passphraseCache.set(newPassphrase)
-    await this.fire(Hook.ChangePassphrase)
+    await this.fire(HOOKS['change-passphrase'])
 
     this._logger.log('passphrase changed')
   }

package/src/dependencies/atoms.js

@@ -1,58 +1,15 @@
-import { createRemoteConfigAtomFactory, createStorageAtomFactory } from '@exodus/atoms'
-import { availableAssetNamesAtomDefinition } from '@exodus/available-assets/atoms'
-import { balancesAtomDefinition } from '@exodus/balances/atoms'
-import {
-  enabledAndDisabledAssetsAtomDefinition,
-  enabledAssetsAtomDefinition,
-} from '@exodus/enabled-assets/atoms'
-
-import baseAssetNamesToMonitorAtomDefinition from '../atoms/base-asset-names-to-monitor'
-import nonDustBalanceAssetNamesAtomDefinition from '../atoms/non-dust-balance-asset-names-atom'
+import { createInMemoryAtom } from '@exodus/atoms'
 import { withType } from './utils'
 
 const createAtomDependencies = () =>
   [
-    {
-      definition: enabledAndDisabledAssetsAtomDefinition,
-      storage: { namespace: 'enabledAssets' },
-    },
-    { definition: enabledAssetsAtomDefinition },
-    { definition: availableAssetNamesAtomDefinition },
-    {
-      definition: nonDustBalanceAssetNamesAtomDefinition,
-    },
-    {
-      definition: {
-        id: 'pricingServerUrlAtom',
-        factory: ({ config, remoteConfig }) =>
-          createRemoteConfigAtomFactory({ remoteConfig })({
-            path: config.pricingServerPath,
-            defaultValue: config.defaultPricingServerUrl,
-          }),
-        dependencies: ['config', 'remoteConfig'],
-      },
-    },
     {
       definition: {
-        id: 'mockConfigAtom',
-        factory: ({ storage }) =>
-          createStorageAtomFactory({ storage })({
-            key: 'mockConfig',
-            defaultValue: {},
-            isSoleWriter: true,
-          }),
-        dependencies: ['storage'],
+        id: 'lockedAtom',
+        factory: () => createInMemoryAtom({ defaultValue: true }),
+        dependencies: [],
       },
-      storage: { namespace: 'mockConfig' },
-      aliases: [
-        {
-          implementationId: 'unsafeStorage',
-          interfaceId: 'storage',
-        },
-      ],
     },
-    { definition: balancesAtomDefinition },
-    { definition: baseAssetNamesToMonitorAtomDefinition },
   ].map(withType('atom'))
 
 export default createAtomDependencies

package/src/dependencies/index.js

@@ -3,11 +3,10 @@
 
 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 = [
@@ -17,9 +16,6 @@ const adapterKeys = [
   'legacyPrivToPub',
   'seedStorage',
   'unsafeStorage',
-  'fusion',
-  'fetch',
-  'freeze',
 ]
 
 const createDependencies = ({ adapters, config }) => {
@@ -37,14 +33,11 @@ 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,16 +1,13 @@
-import availableAssetsModuleDefinition from '@exodus/available-assets/module'
-import balancesDefinition from '@exodus/balances/module'
-import enabledAssetsModuleDefinition from '@exodus/enabled-assets/module'
-import createExodusPricingClient from '@exodus/exodus-pricing-client'
+import { createKeychain } from '@exodus/keychain'
+import walletDefinition from '@exodus/wallet/module'
 import createKeyIdentifierProvider from '@exodus/key-identifier-provider'
-import keychainDefinition from '@exodus/keychain/module'
 import walletCompatibilityModesDefinition from '@exodus/wallet-compatibility-modes/module'
 
 import createApplication from '../application'
-import unlockEncryptedStorageDefinition from '../unlock-encrypted-storage'
 import { withType } from './utils'
+import unlockEncryptedStorageDefinition from '../unlock-encrypted-storage'
 
-const createModuleDependencies = ({ config }) =>
+const createModuleDependencies = () =>
   [
     {
       definition: {
@@ -27,22 +24,19 @@ const createModuleDependencies = ({ config }) =>
       },
     },
     {
-      definition: keychainDefinition,
+      definition: {
+        id: 'keychain',
+        factory: createKeychain,
+        dependencies: ['legacyPrivToPub'],
+      },
     },
     {
-      definition: walletCompatibilityModesDefinition,
+      definition: walletDefinition,
     },
-    { definition: unlockEncryptedStorageDefinition },
-    { definition: enabledAssetsModuleDefinition, writesAtoms: ['enabledAndDisabledAssetsAtom'] },
-    { definition: availableAssetsModuleDefinition, writesAtoms: ['availableAssetNamesAtom'] },
     {
-      definition: {
-        id: 'pricingClient',
-        factory: createExodusPricingClient,
-        dependencies: ['fetch', 'pricingServerUrlAtom'],
-      },
+      definition: walletCompatibilityModesDefinition,
     },
-    { definition: balancesDefinition, writesAtoms: ['balancesAtom'] },
+    { definition: unlockEncryptedStorageDefinition },
   ].map(withType('module'))
 
 export default createModuleDependencies

package/src/index.js

@@ -1,74 +1,24 @@
-import { pick } from '@exodus/basic-utils'
-
-import createApi from './api'
-import attachAtoms from './atoms/attach'
-import { atomsToAttach } from './constants'
 import createIOC from './ioc'
-import abTesting from './modules/ab-testing'
-import addressProvider from './modules/address-provider'
-import apyRates from './modules/apy-rates'
-import blockchainMetadata from './modules/blockchain-metadata'
-import connectedOrigins from './modules/connected-origins'
-import cryptoNews from './modules/crypto-news'
-import featureFlags from './modules/feature-flags'
-import fees from './modules/fees'
-import geolocation from './modules/geolocation'
-import kyc from './modules/kyc'
-import locale from './modules/locale'
-import marketHistory from './modules/market-history'
-import nfts from './modules/nfts'
-import personalNotes from './modules/personal-notes'
-import rates from './modules/rates'
-import referrals from './modules/referrals'
-import remoteConfig from './modules/remote-config'
-import topMovers from './modules/top-movers'
-import wallet from './modules/wallet'
-import walletAccounts from './modules/wallet-accounts'
-import attachPlugins from './plugins/attach'
+import createApi from './api'
 
 const createExodus = ({ adapters, config, port }) => {
   const ioc = createIOC({ adapters, config })
-  const { headless: headlessConfig, topMoversMonitor } = config
-
-  ioc.use(wallet())
-  ioc.use(walletAccounts())
-  ioc.use(blockchainMetadata())
-  ioc.use(remoteConfig())
-  ioc.use(geolocation())
-  ioc.use(marketHistory())
-  ioc.use(fees())
-  ioc.use(rates())
-  ioc.use(apyRates())
-  ioc.use(featureFlags())
-  ioc.use(locale())
-  ioc.use(nfts())
-  ioc.use(kyc())
-  ioc.use(referrals())
-  ioc.use(connectedOrigins())
-  ioc.use(abTesting())
-  ioc.use(personalNotes())
-  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, enabledAssets, unlockEncryptedStorage } = ioc.getByType('module')
+    const { application, unlockEncryptedStorage } = ioc.getByType('module')
 
-    application.hook('start', (payload) => {
-      port.emit('start', payload)
+    application.hook('start', () => {
+      port.emit('start')
     })
 
     application.hook('unlock', async () => {
       if (typeof storage.unlock === 'function') unlockEncryptedStorage(storage)
 
       await assetsModule.load()
-      await enabledAssets.load()
     })
 
     application.on('unlock', () => {
@@ -76,14 +26,8 @@ const createExodus = ({ adapters, config, port }) => {
     })
 
     application.hook('clear', async () => {
-      await Promise.all([
-        //
-        assetsModule.clear(),
-        enabledAssets.clear(),
-      ])
-    })
+      await Promise.all([assetsModule.clear()])
 
-    application.on('clear', () => {
       port.emit('clear')
     })
 
@@ -91,19 +35,7 @@ const createExodus = ({ adapters, config, port }) => {
       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'),
-      logger: ioc.get('createLogger')('attachPlugins'),
-    })
+    application.start()
 
     return createApi({ ioc, port })
   }

package/src/ioc.js

@@ -1,56 +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 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()]
+  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])
-  }
-
-  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 }
+  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) => {

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