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

package/src/api.js

@@ -1,48 +1,13 @@
 import { validateMnemonic as isMnemonicValid } from 'bip39'
 
 const createApi = ({ ioc, port }) => {
-  const { assetsModule } = ioc.getByType('adapter')
+  const { passphraseCache } = ioc.getByType('adapter')
 
-  const {
-    addressProvider,
-    application,
-    blockchainMetadata,
-    connectedOrigins,
-    enabledAssets,
-    kyc,
-    nfts,
-    personalNotes,
-    referrals,
-    remoteConfig,
-    wallet,
-    walletAccounts,
-  } = ioc.getByType('module')
-
-  const { feeMonitors, ratesMonitor, nftsMonitor } = ioc.getByType('monitor')
-  // TODO: decide where this belongs
-  const { passphraseCache } = ioc.getAll()
-
-  const {
-    // ...
-    currencyAtom,
-    enabledWalletAccountsAtom,
-    languageAtom,
-    connectedOriginsAtom,
-  } = ioc.getByType('atom')
-
-  // TODO: do this on 'unload'
-  const stop = () => {
-    kyc.stop()
-    referrals.stop()
-    remoteConfig.stop()
-    feeMonitors.stop()
-    nftsMonitor.stop()
-  }
+  const { application, wallet } = ioc.getByType('module')
 
   return {
     wallet: {
       exists: () => wallet.exists(),
-      start: application.start,
       load: application.load,
       unload: application.unload,
       create: application.create,
@@ -62,85 +27,9 @@ const createApi = ({ ioc, port }) => {
       changeLockTimer: application.changeLockTimer,
       isLocked: () => wallet.isLocked(),
     },
-    walletAccounts: {
-      create: walletAccounts.create,
-      update: walletAccounts.update,
-      disable: walletAccounts.disable,
-      enable: walletAccounts.enable,
-      getEnabled: enabledWalletAccountsAtom.get,
-    },
-    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,
-    },
-    assets: {
-      enable: enabledAssets.enable,
-      disable: enabledAssets.disable,
-      addAndEnableToken: async (...args) => {
-        const asset = await assetsModule.addToken(...args)
-        await enabledAssets.enable([asset.name])
-        return asset.name
-      },
-    },
-    remoteConfig: {
-      get: remoteConfig.get,
-      getAll: remoteConfig.getAll,
-    },
-    locale: {
-      setLanguage: (value) => languageAtom.set(value),
-      setCurrency: (value) => currencyAtom.set(value),
-    },
-    rates: {
-      refresh: () => ratesMonitor.update(),
-    },
-    addressProvider: {
-      getAddress: addressProvider.getAddress.bind(addressProvider),
-      getSupportedPurposes: addressProvider.getSupportedPurposes.bind(addressProvider),
-      getReceiveAddress: addressProvider.getReceiveAddress.bind(addressProvider),
-    },
-    kyc: {
-      start: kyc.start,
-      sync: kyc.sync,
-      requestKycToken: kyc.requestKycToken,
-    },
-    referrals: {
-      setReferredBy: referrals.setReferredBy,
-      referralCodeExists: referrals.referralCodeExists,
-    },
-    personalNotes: {
-      upsert: personalNotes.upsert,
-    },
-    nfts: {
-      upsertConfig: nfts.upsertConfig,
-      setMonitorInterval: nftsMonitor.setInterval,
-    },
-    connectedOrigins: {
-      get: connectedOriginsAtom.get,
-      add: connectedOrigins.add,
-      clear: connectedOrigins.clear,
-      untrust: connectedOrigins.untrust,
-      isTrusted: connectedOrigins.isTrusted,
-      isAutoApprove: connectedOrigins.isAutoApprove,
-      setFavorite: connectedOrigins.setFavorite,
-      setAutoApprove: connectedOrigins.setAutoApprove,
-      connect: connectedOrigins.connect,
-      disconnect: connectedOrigins.disconnect,
-      updateConnection: connectedOrigins.updateConnection,
-      clearConnections: connectedOrigins.clearConnections,
-    },
     isMnemonicValid,
     subscribe: port.subscribe.bind(port),
     unsubscribe: port.unsubscribe.bind(port),
-    stop,
   }
 }
 

package/src/application.js

@@ -17,25 +17,23 @@ 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 Hook = Object.freeze({
-  Lock: 'lock',
-  Unlock: 'unlock',
-  Clear: 'clear',
-  Import: 'import',
-  Migrate: 'migrate',
-  Start: 'start',
-  Load: 'load',
-  Unload: 'unload',
-  Create: 'create',
-  Backup: 'backup',
-  Restore: 'restore',
-  RestoreCompleted: 'restore-completed',
-  AssetsSynced: 'assets-synced',
-  ChangePassphrase: 'change-passphrase',
+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',
 })
 
-const HOOKS = new Set(Object.values(Hook))
-
 class Application extends ExodusModule {
   #hooks = {}
   #wallet = null
@@ -52,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 () => {
@@ -66,31 +63,12 @@ class Application extends ExodusModule {
     if (isDeleting || isImporting) {
       await this.#storage.batchDelete([DELETE_FLAG, IMPORT_FLAG])
       await this.#passphraseCache.clear()
+      await this.fire(HOOKS.clear)
     }
 
-    const walletExists = await this.#wallet.exists()
-
-    if (isImporting || !walletExists) {
-      await this.fire(Hook.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()
@@ -110,7 +88,7 @@ class Application extends ExodusModule {
       this.isRestoring(),
     ])
 
-    await this.fire(Hook.Load, {
+    await this.fire(HOOKS.load, {
       walletExists,
       hasPassphraseSet,
       isLocked,
@@ -121,11 +99,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] = []
@@ -135,7 +113,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] || []
@@ -153,15 +131,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) => {
@@ -171,28 +141,26 @@ class Application extends ExodusModule {
 
     await this.#applicationStarted
 
-    const walletExists = await this.#wallet.exists()
-
-    const { forceRestart, ...wallet } = opts
-
-    await this.#wallet.import(wallet)
-
-    if (forceRestart || walletExists) {
+    if (await this.#wallet.exists()) {
+      await this.#wallet.import(opts)
       await this.#storage.set(IMPORT_FLAG, true)
 
       this.emit('restart', { reason: 'import' })
-    } else {
-      await this.fire(Hook.Import)
 
-      this._logger.log('wallet imported')
+      return
     }
+
+    await this.#wallet.import(opts)
+    await this.fire(HOOKS.import)
+
+    this._logger.log('wallet imported')
   }
 
   getMnemonic = async (opts) => this.#wallet.getMnemonic(opts)
 
   setBackedUp = async () => {
     await this.#wallet.setBackedUp()
-    await this.fire(Hook.Backup)
+    await this.fire(HOOKS.backup)
   }
 
   lock = async (opts) => {
@@ -201,7 +169,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')
   }
@@ -210,13 +178,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 () => {
@@ -229,7 +197,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()
 
@@ -245,8 +213,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()
 
@@ -261,7 +229,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,34 +1,4 @@
-import { apyRatesAtomDefinition } from '@exodus/apy-rates/atoms'
-import {
-  createFusionAtomFactory,
-  createInMemoryAtom,
-  createRemoteConfigAtomFactory,
-  createStorageAtomFactory,
-} from '@exodus/atoms'
-import { availableAssetNamesAtomDefinition } from '@exodus/available-assets/atoms'
-import { balancesAtomDefinition } from '@exodus/balances/atoms'
-import { connectedOriginsAtomDefinition } from '@exodus/connected-origins/atoms'
-import { cryptoNewsAtomDefinition } from '@exodus/crypto-news-monitor/atoms'
-import {
-  enabledAndDisabledAssetsAtomDefinition,
-  enabledAssetsAtomDefinition,
-} from '@exodus/enabled-assets/atoms'
-import { featureFlagsAtomDefinition } from '@exodus/feature-flags/atoms'
-import { geolocationAtomDefinition } from '@exodus/geolocation/atoms'
-import { kycAtomDefinition } from '@exodus/kyc/atoms'
-import { nftsCacheAtomDefinition, nftsConfigsAtomDefinition } from '@exodus/nfts/atoms'
-import { personalNotesAtomDefinition } from '@exodus/personal-notes/atoms'
-import { ratesAtomDefinition } from '@exodus/rates-monitor/atoms'
-import { referralsAtomDefinition } from '@exodus/referrals/atoms'
-import { topMoversAtomDefinition } from '@exodus/top-movers-monitor/atoms'
-import {
-  enabledWalletAccountsAtomDefinition,
-  walletAccountsAtomDefinition,
-} from '@exodus/wallet-accounts/atoms'
-
-import baseAssetNamesToMonitorAtomDefinition from '../atoms/base-asset-names-to-monitor'
-import nonDustBalanceAssetNamesAtomDefinition from '../atoms/non-dust-balance-asset-names-atom'
-import restoreAtomDefinition from '../atoms/restore'
+import { createInMemoryAtom } from '@exodus/atoms'
 import { withType } from './utils'
 
 const createAtomDependencies = () =>
@@ -40,145 +10,6 @@ const createAtomDependencies = () =>
         dependencies: [],
       },
     },
-    {
-      definition: walletAccountsAtomDefinition,
-      storage: { namespace: 'walletAccounts' },
-    },
-    { definition: enabledWalletAccountsAtomDefinition },
-    {
-      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: 'languageAtom',
-        factory: ({ storage, config }) =>
-          createStorageAtomFactory({ storage })({
-            key: 'language',
-            defaultValue: config.defaultValue,
-            isSoleWriter: true,
-          }),
-        dependencies: ['storage', 'config'],
-      },
-      aliases: [
-        {
-          implementationId: 'unsafeStorage',
-          interfaceId: 'storage',
-        },
-      ],
-      storage: { namespace: 'locale' },
-    },
-    {
-      definition: {
-        id: 'currencyAtom',
-        factory: ({ fusion, config }) =>
-          createFusionAtomFactory({ fusion })({
-            path: `private.currency`,
-            defaultValue: config.defaultValue,
-          }),
-        dependencies: ['fusion', 'config'],
-      },
-    },
-    // TODO: move to @exodus/market-history
-    {
-      definition: {
-        id: 'marketHistoryClearCacheAtom',
-        factory: ({ config }) => createInMemoryAtom(config),
-        dependencies: ['config'],
-      },
-    },
-    // TODO: move to @exodus/market-history
-    {
-      definition: {
-        id: 'remoteConfigClearMarketHistoryCacheAtom',
-        factory: ({ config, remoteConfig }) =>
-          createRemoteConfigAtomFactory({ remoteConfig })(config),
-        dependencies: ['config', 'remoteConfig'],
-      },
-    },
-    // TODO: move to @exodus/market-history
-    {
-      definition: {
-        id: 'marketHistoryRefreshIntervalAtom',
-        factory: ({ config, remoteConfig }) =>
-          createRemoteConfigAtomFactory({ remoteConfig })(config),
-        dependencies: ['config', 'remoteConfig'],
-      },
-    },
-    {
-      definition: {
-        id: 'mockConfigAtom',
-        factory: ({ storage }) =>
-          createStorageAtomFactory({ storage })({
-            key: 'mockConfig',
-            defaultValue: {},
-            isSoleWriter: true,
-          }),
-        dependencies: ['storage'],
-      },
-      storage: { namespace: 'mockConfig' },
-      aliases: [
-        {
-          implementationId: 'unsafeStorage',
-          interfaceId: 'storage',
-        },
-      ],
-    },
-    { definition: balancesAtomDefinition },
-    { definition: ratesAtomDefinition },
-    { definition: geolocationAtomDefinition },
-    { definition: featureFlagsAtomDefinition },
-    { definition: kycAtomDefinition },
-    { definition: referralsAtomDefinition },
-    {
-      definition: personalNotesAtomDefinition,
-      aliases: [
-        {
-          implementationId: 'personalNotesStorage',
-          interfaceId: 'storage',
-        },
-      ],
-    },
-    {
-      definition: connectedOriginsAtomDefinition,
-      storage: { namespace: 'connectedOrigins' },
-      aliases: [
-        {
-          implementationId: 'unsafeStorage',
-          interfaceId: 'storage',
-        },
-      ],
-    },
-    { definition: baseAssetNamesToMonitorAtomDefinition },
-    { definition: topMoversAtomDefinition },
-    { definition: cryptoNewsAtomDefinition },
-    { definition: restoreAtomDefinition },
-    { definition: apyRatesAtomDefinition },
-    {
-      definition: nftsCacheAtomDefinition,
-      storage: { namespace: 'nftsCache' },
-    },
-    {
-      definition: nftsConfigsAtomDefinition,
-      aliases: [{ implementationId: 'unsafeStorage', interfaceId: 'storage' }],
-      storage: { namespace: 'nfts-config' },
-    },
   ].map(withType('atom'))
 
 export default createAtomDependencies

package/src/dependencies/index.js

@@ -3,13 +3,10 @@
 
 import assert from 'minimalistic-assert'
 
+import createConfigDependencies from './configs'
 import createAdapterDependencies from './adapters'
-import createAtomCollectionDependencies from './atom-collections'
 import createAtomDependencies from './atoms'
-import createConfigDependencies from './configs'
 import createModuleDependencies from './modules'
-import createMonitorDependencies from './monitors'
-import createPluginDependencies from './plugins'
 import { wrapConstant } from './utils'
 
 const adapterKeys = [
@@ -19,9 +16,6 @@ const adapterKeys = [
   'legacyPrivToPub',
   'seedStorage',
   'unsafeStorage',
-  'fusion',
-  'fetch',
-  'freeze',
 ]
 
 const createDependencies = ({ adapters, config }) => {
@@ -35,24 +29,15 @@ const createDependencies = ({ adapters, config }) => {
 
   const modules = createModuleDependencies({ adapters, config })
 
-  const monitors = createMonitorDependencies({ adapters, config })
-
   const atoms = createAtomDependencies({ adapters, config })
 
-  const atomCollections = createAtomCollectionDependencies({ adapters, config })
-
   const adaptersTree = createAdapterDependencies({ adapters, config })
 
-  const plugins = createPluginDependencies()
-
   return []
     .concat(adaptersTree)
     .concat(configs)
     .concat(modules)
-    .concat(monitors)
     .concat(atoms)
-    .concat(atomCollections)
-    .concat(plugins)
     .concat(wrapConstant({ id: 'logger', type: 'module', value: logger }))
 }
 

package/src/dependencies/modules.js

@@ -1,28 +1,12 @@
-import createAddressProviderDependencies from '@exodus/address-provider'
-import availableAssetsModuleDefinition from '@exodus/available-assets/module'
-import balancesDefinition from '@exodus/balances/module'
-import blockchainMetadataDefinition from '@exodus/blockchain-metadata/module'
-import createRemoteConfig from '@exodus/config/remote'
-import connectedOriginsDefinition from '@exodus/connected-origins/module'
-import enabledAssetsModuleDefinition from '@exodus/enabled-assets/module'
-import createExodusPricingClient from '@exodus/exodus-pricing-client'
-import featureFlagsDefinition from '@exodus/feature-flags/module'
-import createKeyIdentifierProvider from '@exodus/key-identifier-provider'
-import keychainDefinition from '@exodus/keychain/module'
-import kycDefinition from '@exodus/kyc/module'
-import nftsModuleDefinition from '@exodus/nfts/module'
-import personalNotesDefinition from '@exodus/personal-notes/module'
-import referralsDefinition from '@exodus/referrals/module'
+import { createKeychain } from '@exodus/keychain'
 import walletDefinition from '@exodus/wallet/module'
-import walletAccountsDefinition from '@exodus/wallet-accounts/module'
+import createKeyIdentifierProvider from '@exodus/key-identifier-provider'
 import walletCompatibilityModesDefinition from '@exodus/wallet-compatibility-modes/module'
-import EventEmitter from 'events/'
 
 import createApplication from '../application'
-import unlockEncryptedStorageDefinition from '../unlock-encrypted-storage'
 import { withType } from './utils'
 
-const createModuleDependencies = ({ config }) =>
+const createModuleDependencies = () =>
   [
     {
       definition: {
@@ -38,71 +22,18 @@ const createModuleDependencies = ({ config }) =>
         dependencies: [],
       },
     },
-    {
-      definition: keychainDefinition,
-    },
-    {
-      definition: walletDefinition,
-      writesAtoms: ['lockedAtom'],
-    },
-    {
-      definition: walletCompatibilityModesDefinition,
-    },
-    { definition: unlockEncryptedStorageDefinition },
-    { definition: walletAccountsDefinition, writesAtoms: ['walletAccountsAtom'] },
-    {
-      definition: blockchainMetadataDefinition,
-      storage: { namespace: ['blockchain', 'v1'] },
-    },
-    { definition: enabledAssetsModuleDefinition, writesAtoms: ['enabledAndDisabledAssetsAtom'] },
-    {
-      definition: {
-        id: 'remoteConfig',
-        factory: (deps) => {
-          const eventEmitter = new EventEmitter().setMaxListeners(Number.POSITIVE_INFINITY)
-          return createRemoteConfig({ eventEmitter, ...deps })
-        },
-        dependencies: ['fetch', 'freeze', 'config', 'logger'],
-      },
-    },
-    { definition: availableAssetsModuleDefinition, writesAtoms: ['availableAssetNamesAtom'] },
     {
       definition: {
-        id: 'pricingClient',
-        factory: createExodusPricingClient,
-        dependencies: ['fetch', 'pricingServerUrlAtom'],
+        id: 'keychain',
+        factory: createKeychain,
+        dependencies: ['legacyPrivToPub'],
       },
     },
-    { definition: balancesDefinition, writesAtoms: ['balancesAtom'] },
-    {
-      definition: featureFlagsDefinition,
-      writesAtoms: ['featureFlagAtoms'],
-    },
-    ...createAddressProviderDependencies(config.addressProvider),
-    {
-      definition: kycDefinition,
-      writesAtoms: ['kycAtom'],
-    },
     {
-      definition: referralsDefinition,
-      storage: { namespace: 'referrals' },
-      writesAtoms: ['referralsAtom'],
-      aliases: [
-        {
-          implementationId: 'unsafeStorage',
-          interfaceId: 'storage',
-        },
-      ],
-    },
-    {
-      definition: personalNotesDefinition,
-    },
-    {
-      definition: connectedOriginsDefinition,
-      writesAtoms: ['connectedOriginsAtom'],
+      definition: walletDefinition,
     },
     {
-      definition: nftsModuleDefinition,
+      definition: walletCompatibilityModesDefinition,
     },
   ].map(withType('module'))