@exodus/headless 2.0.0-alpha.14 → 2.0.0-alpha.140

package/README.md

@@ -15,6 +15,7 @@ The headless Exodus wallet SDK
 
 ```js
 import createExodus from '@exodus/headless'
+import referrals from '@exodus/headless/src/modules/referrals'
 import Emitter from '@exodus/wild-emitter'
 
 // 1. Create port. Acts as an event bus between headless wallet and client
@@ -25,10 +26,10 @@ const adapters = {}
 const config = {}
 
 // 3. Create Exodus container
-const container = createExodus({ port, adapters, config })
+const exodusContainer = createExodus({ port, adapters, config })
 
 // 4. Register external modules. Does not support overriding modules at the moment.
-container.register({
+exodusContainer.register({
   definition: {
     id: 'remoteConfig',
     factory: createRemoteConfig,
@@ -36,11 +37,22 @@ container.register({
   },
 })
 
+// see an example feature definition:
+// https://github.com/ExodusMovement/exodus-hydra/blob/2e8d63426421ffcbec84a9b6fbc83eb913b47eba/modules/headless/src/modules/geolocation/index.js
+exodusContainer.use(referrals())
+exodusContainer.use(myCustomFeature({ id: 'myCustomFeature', ... }))
+
 // 5. Resolve exodus instance
-const exodus = container.resolve()
+const exodus = exodusContainer.resolve()
+
+// 6. Start exodus instance
+await exodus.wallet.start()
 
-// 6. Use it!
+// 7. Use it!
 await exodus.wallet.create({ passphrase: 'my-super-secure-passphrase' })
+
+// 8. Use your custom feature API, if any
+exodus.myCustomFeature.doThatThingYouDo()
 ```
 
 ## Lifecycle

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@exodus/headless",
-  "version": "2.0.0-alpha.14",
-  "description": "The headless Exodus wallet SDK",
-  "author": "Exodus Movement Inc",
+  "version": "2.0.0-alpha.140",
+  "description": "The platform-agnostic Exodus wallet SDK",
+  "author": "Exodus Movement Inc.",
   "main": "src/index.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/exodus-hydra.git"
   },
-  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/modules/headless",
+  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/sdks/headless",
   "license": "UNLICENSED",
   "bugs": {
     "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Aheadless"
@@ -17,56 +17,86 @@
     "src",
     "README.md",
     "CHANGELOG.md",
-    "!**/__tests__",
+    "!**/__tests__/**",
     "!**/*.test.js"
   ],
   "scripts": {
     "lint": "eslint . --ignore-path ../../.gitignore",
     "lint:fix": "yarn lint --fix",
-    "test": "jest"
+    "test": "NODE_OPTIONS=--max-old-space-size=4096 jest"
   },
   "dependencies": {
-    "@exodus/atoms": "^2.9.0",
-    "@exodus/available-assets": "^2.0.0",
-    "@exodus/balances": "^6.0.0",
+    "@exodus/address-provider": "^8.0.0",
+    "@exodus/assets-feature": "^3.7.0",
+    "@exodus/atoms": "^6.0.0",
+    "@exodus/auto-enable-assets-plugin": "^4.3.0",
+    "@exodus/available-assets": "^7.0.0",
+    "@exodus/balances": "^11.1.0",
     "@exodus/basic-utils": "^2.0.0",
-    "@exodus/blockchain-metadata": "^8.0.1",
-    "@exodus/config": "7.0.0",
-    "@exodus/dependency-injection": "^1.2.0",
-    "@exodus/dependency-preprocessors": "^2.0.2",
-    "@exodus/enabled-assets": "^6.0.0",
-    "@exodus/exodus-pricing-client": "^1.1.0",
+    "@exodus/blockchain-metadata": "^14.2.0",
+    "@exodus/dependency-injection": "^2.0.1",
+    "@exodus/dependency-preprocessors": "^3.1.1",
+    "@exodus/enabled-assets": "^9.0.1",
+    "@exodus/feature-flags": "^4.2.0",
+    "@exodus/fee-data-monitors": "^3.0.0",
     "@exodus/fetch": "^1.2.1",
-    "@exodus/key-identifier-provider": "^1.1.3",
-    "@exodus/keychain": "^4.0.0",
-    "@exodus/market-history": "^3.1.0",
-    "@exodus/module": "^1.0.0",
-    "@exodus/rates-monitor": "^2.0.0",
-    "@exodus/wallet": "^6.0.1",
-    "@exodus/wallet-accounts": "^8.0.1",
-    "@exodus/wallet-compatibility-modes": "^2.0.0",
-    "bip39": "2.6.0",
+    "@exodus/geolocation": "^3.0.0",
+    "@exodus/hd-key-slip-10": "^2.0.0",
+    "@exodus/key-identifier-provider": "^1.3.1",
+    "@exodus/keychain": "^4.3.0",
+    "@exodus/locale": "^2.0.2",
+    "@exodus/module": "^1.2.0",
+    "@exodus/pricing": "^1.1.0",
+    "@exodus/rates-monitor": "^4.0.2",
+    "@exodus/remote-config": "^2.3.0",
+    "@exodus/restore-progress-tracker": "^3.0.0",
+    "@exodus/sodium-crypto": "^3.2.0",
+    "@exodus/tx-signer": "^1.1.0",
+    "@exodus/wallet": "^10.0.2",
+    "@exodus/wallet-accounts": "^14.2.0",
+    "@exodus/wallet-compatibility-modes": "^3.1.2",
+    "bip39": "^2.6.0",
     "events": "^3.3.0",
-    "lodash": "https://registry.yarnpkg.com/@exodus/lodash/-/lodash-4.17.21-exodus.2.tgz",
+    "lodash": "npm:@exodus/lodash@^4.17.21-exodus.2",
     "minimalistic-assert": "^1.0.1"
   },
   "devDependencies": {
-    "@exodus/bitcoin-meta": "^1.0.0",
+    "@exodus/ab-testing": "^7.0.1",
+    "@exodus/algorand-lib": "^2.0.1",
+    "@exodus/algorand-meta": "^1.1.4",
+    "@exodus/apy-rates": "^3.3.1",
+    "@exodus/assets-feature": "workspace:^",
+    "@exodus/bitcoin-plugin": "^1.0.14",
+    "@exodus/connected-origins": "^3.3.0",
+    "@exodus/crypto-news-monitor": "^4.1.0",
     "@exodus/currency": "^2.2.0",
-    "@exodus/ethereum-lib": "^2.22.2",
+    "@exodus/ethereum-lib": "^3.3.34",
     "@exodus/ethereum-meta": "^1.0.23",
-    "@exodus/models": "^8.11.1",
+    "@exodus/exodus-pricing-client": "^1.2.0",
+    "@exodus/key-utils": "^3.0.0",
+    "@exodus/kyc": "^4.2.0",
+    "@exodus/litecoin-meta": "^1.0.0",
+    "@exodus/market-history": "^7.1.0",
+    "@exodus/models": "^10.1.0",
+    "@exodus/nfts": "^6.4.1",
+    "@exodus/personal-notes": "^3.6.0",
+    "@exodus/referrals": "^8.0.1",
     "@exodus/solana-lib": "^1.3.11",
     "@exodus/solana-meta": "^1.0.2",
     "@exodus/storage-encrypted": "^1.1.2",
-    "@exodus/storage-memory": "^1.1.0",
+    "@exodus/storage-memory": "^2.1.1",
+    "@exodus/top-movers-monitor": "^3.2.0",
+    "@exodus/ui-config": "^3.2.0",
     "@exodus/wild-emitter": "^1.0.0",
     "buffer-json": "^2.0.0",
     "deepmerge": "^4.2.2",
-    "eslint": "^8.33.0",
+    "delay": "^5.0.0",
+    "eslint": "^8.44.0",
+    "eslint-plugin-simple-import-sort": "^7.0.0",
     "events": "^3.3.0",
     "jest": "^29.1.2",
+    "msw": "^1.3.0",
     "p-defer": "^4.0.0"
   },
-  "gitHead": "9abcdc848bb0aa6f5297f7db643c34ff27db6acb"
+  "gitHead": "1f654f0ebc89d0666b6342b162d94b960b0302a7"
 }

package/src/api.js

@@ -1,83 +1,13 @@
 import { validateMnemonic as isMnemonicValid } from 'bip39'
 
-const createApi = ({ ioc, port }) => {
-  const { passphraseCache } = ioc.getByType('adapter')
+import createReporting from './reporting'
 
-  const { application, blockchainMetadata, enabledAssets, remoteConfig, wallet, walletAccounts } =
-    ioc.getByType('module')
-
-  const { ratesMonitor } = ioc.getByType('monitor')
-  const { assetsModule } = ioc.getByType('adapter')
-
-  const {
-    // ...
-    currencyAtom,
-    enabledWalletAccountsAtom,
-    languageAtom,
-  } = ioc.getByType('atom')
+const createApi = ({ ioc, port, lockedAtom, config }) => {
+  const apis = ioc.getByType('api')
 
   return {
-    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(),
-    },
-    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(),
-    },
+    ...Object.assign({}, ...Object.values(apis)),
+    ...createReporting({ ioc, lockedAtom, config }),
     isMnemonicValid,
     subscribe: port.subscribe.bind(port),
     unsubscribe: port.unsubscribe.bind(port),

package/src/application.js

@@ -3,6 +3,8 @@
 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.
@@ -17,23 +19,6 @@ 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 = new Set(Object.values(Hook))
 
 class Application extends ExodusModule {
@@ -71,12 +56,26 @@ class Application extends ExodusModule {
     const walletExists = await this.#wallet.exists()
 
     if (isImporting || !walletExists) {
-      await this.fire(Hook.Clear)
+      await this.fire(Hook.Clear, null, { concurrent: true })
     }
 
     if (isImporting) await this.fire(Hook.Import)
 
-    await this.fire(Hook.Start)
+    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,
+    })
+
     await this.#autoUnlock()
 
     const locked = await this.#wallet.isLocked()
@@ -120,14 +119,28 @@ class Application extends ExodusModule {
     this.#hooks[hookName].push(listener)
   }
 
-  fire = async (hookName, params) => {
+  fire = async (hookName, params, { concurrent } = {}) => {
     assert(HOOKS.has(hookName), `no such hook: ${hookName}`)
-    this._logger.debug('firing hooks', hookName)
+
+    this._logger.debug(`firing hooks ${concurrent ? 'concurrently' : 'sequentially'}`, hookName)
 
     const hooks = this.#hooks[hookName] || []
 
-    for (let i = 0; i < hooks.length; i++) {
-      await hooks[i](params)
+    const hookFns = hooks.map((hook) => async () => {
+      try {
+        await hook(params)
+      } catch (err) {
+        this._logger.error(`application lifecycle hook failed: ${hookName}`, hook.name, params, err)
+        throw err
+      }
+    })
+
+    if (concurrent) {
+      await Promise.allSettled(hookFns.map((promise) => promise()))
+    } else {
+      for (let i = 0; i < hookFns.length; i++) {
+        await hookFns[i]()
+      }
     }
 
     this.emit(hookName, params)
@@ -139,7 +152,15 @@ class Application extends ExodusModule {
     await this.#applicationStarted
     await this.#wallet.create(opts)
 
-    await this.fire(Hook.Create, { hasPassphraseSet: !!opts?.passphrase })
+    const isLocked = await this.#wallet.isLocked()
+
+    await this.fire(Hook.Create, {
+      hasPassphraseSet: !!opts?.passphrase,
+      isBackedUp: false,
+      isLocked,
+      isRestoring: false,
+      walletExists: true,
+    })
   }
 
   import = async (opts) => {
@@ -151,14 +172,14 @@ class Application extends ExodusModule {
 
     const walletExists = await this.#wallet.exists()
 
-    const { forceRestart, ...wallet } = opts
+    const { forceRestart, forgotPassphrase, ...wallet } = opts
 
     await this.#wallet.import(wallet)
 
     if (forceRestart || walletExists) {
       await this.#storage.set(IMPORT_FLAG, true)
 
-      this.emit('restart', { reason: 'import' })
+      await this.fire(Hook.Restart, { reason: 'import' })
     } else {
       await this.fire(Hook.Import)
 
@@ -207,6 +228,8 @@ class Application extends ExodusModule {
       this._logger.log('unlocking with cache')
 
       await this.#wallet.unlock({ passphrase })
+
+      await this.fire(Hook.Migrate)
       await this.fire(Hook.Unlock)
 
       this.#restoreIfNeeded()
@@ -244,15 +267,23 @@ class Application extends ExodusModule {
     this._logger.log('passphrase changed')
   }
 
-  delete = async () => {
+  delete = async ({ forgotPassphrase } = {}) => {
     await this.#storage.set(DELETE_FLAG, true)
-    this.emit('restart', { reason: 'delete' })
+    await this.fire(Hook.Restart, { reason: 'delete', forgotPassphrase })
+  }
+
+  stop = async () => {
+    await this.fire(Hook.Stop)
   }
 
   changeLockTimer = async ({ ttl }) => {
     await this.#passphraseCache.changeTtl(ttl)
   }
 
+  restartAutoLockTimer = async () => {
+    await this.#passphraseCache.scheduleClear()
+  }
+
   isRestoring = async () => {
     return this.#storage.get(RESTORE_FLAG)
   }

package/src/atoms/base-asset-names-to-monitor.js

@@ -0,0 +1,40 @@
+import { combine, compute, dedupe } 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 dedupe(
+    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,8 +1,18 @@
-export const atomsToAttach = [
-  'availableAssetNamesAtom',
-  'currencyAtom',
-  'enabledWalletAccountsAtom',
-  'languageAtom',
-  'walletAccountsAtom',
-  'balancesAtom',
-]
+export const LifecycleHook = Object.freeze({
+  Lock: 'lock',
+  Unlock: 'unlock',
+  Clear: 'clear',
+  Import: 'import',
+  Migrate: 'migrate',
+  Start: 'start',
+  Stop: 'stop',
+  Restart: 'restart',
+  Load: 'load',
+  Unload: 'unload',
+  Create: 'create',
+  Backup: 'backup',
+  Restore: 'restore',
+  RestoreCompleted: 'restore-completed',
+  AssetsSynced: 'assets-synced',
+  ChangePassphrase: 'change-passphrase',
+})

package/src/dependencies/atoms.js

@@ -1,111 +1,5 @@
-import {
-  createInMemoryAtom,
-  createRemoteConfigAtomFactory,
-  createStorageAtomFactory,
-  createFusionAtomFactory,
-} from '@exodus/atoms'
-import {
-  walletAccountsAtomDefinition,
-  enabledWalletAccountsAtomDefinition,
-} from '@exodus/wallet-accounts/atoms'
+import baseAssetNamesToMonitorAtomDefinition from '../atoms/base-asset-names-to-monitor'
 
-import {
-  enabledAndDisabledAssetsAtomDefinition,
-  enabledAssetsAtomDefinition,
-} from '@exodus/enabled-assets/atoms'
-
-import { availableAssetNamesAtomDefinition } from '@exodus/available-assets/atoms'
-import { ratesAtomDefinition } from '@exodus/rates-monitor/atoms'
-
-import { withType } from './utils'
-import { balancesAtomDefinition } from '@exodus/balances/atoms'
-
-const createAtomDependencies = () =>
-  [
-    {
-      definition: {
-        id: 'lockedAtom',
-        factory: () => createInMemoryAtom({ defaultValue: true }),
-        dependencies: [],
-      },
-    },
-    {
-      definition: walletAccountsAtomDefinition,
-      storage: { namespace: 'walletAccounts' },
-    },
-    { definition: enabledWalletAccountsAtomDefinition },
-    { definition: enabledAndDisabledAssetsAtomDefinition },
-    { definition: enabledAssetsAtomDefinition },
-    { definition: availableAssetNamesAtomDefinition },
-    {
-      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: balancesAtomDefinition },
-    { definition: ratesAtomDefinition },
-  ].map(withType('atom'))
+const createAtomDependencies = () => [{ definition: baseAssetNamesToMonitorAtomDefinition }]
 
 export default createAtomDependencies

package/src/dependencies/index.js

@@ -3,22 +3,18 @@
 
 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 createMonitorDependencies from './monitors'
-import { wrapConstant } from './utils'
 import createPluginDependencies from './plugins'
+import { wrapConstant } from './utils'
 
 const adapterKeys = [
-  // ...
-  'assetsModule',
   'createLogger',
   'legacyPrivToPub',
   'seedStorage',
   'unsafeStorage',
-  'fusion',
   'fetch',
   'freeze',
 ]
@@ -34,8 +30,6 @@ const createDependencies = ({ adapters, config }) => {
 
   const modules = createModuleDependencies({ adapters, config })
 
-  const monitors = createMonitorDependencies({ adapters, config })
-
   const atoms = createAtomDependencies({ adapters, config })
 
   const adaptersTree = createAdapterDependencies({ adapters, config })
@@ -46,7 +40,6 @@ const createDependencies = ({ adapters, config }) => {
     .concat(adaptersTree)
     .concat(configs)
     .concat(modules)
-    .concat(monitors)
     .concat(atoms)
     .concat(plugins)
     .concat(wrapConstant({ id: 'logger', type: 'module', value: logger }))