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

package/README.md

@@ -2,20 +2,10 @@
 
 The headless Exodus wallet SDK
 
-## Table of Contents
-
-- [Quick Start](#quick-start)
-- [Lifecycle](#lifecycle)
-- [Port](#port)
-- [Adapters](#adapters)
-- [Config](#config)
-- [Headless API](#headless-api)
-
 ## Quick Start
 
 ```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
@@ -26,10 +16,10 @@ const adapters = {}
 const config = {}
 
 // 3. Create Exodus container
-const exodusContainer = createExodus({ port, adapters, config })
+const container = createExodus({ port, adapters, config })
 
 // 4. Register external modules. Does not support overriding modules at the moment.
-exodusContainer.register({
+container.register({
   definition: {
     id: 'remoteConfig',
     factory: createRemoteConfig,
@@ -37,83 +27,13 @@ exodusContainer.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 = exodusContainer.resolve()
+const exodus = container.resolve()
 
-// 6. Start exodus instance
-await exodus.wallet.start()
-
-// 7. Use it!
+// 6. Use it!
 await exodus.wallet.create({ passphrase: 'my-super-secure-passphrase' })
-
-// 8. Use your custom feature API, if any
-exodus.myCustomFeature.doThatThingYouDo()
 ```
 
-## Lifecycle
-
-The headless wallet instance transitions through different states during his life. When moving from one another, there are two things that are triggered:
-
-- Fires hook call: Allows modules to subscribe and halt transition until listener resolves.
-- Fires event call: Emitted after all hooks had been executed and resolved.
-
-Below you can find a state diagram that visualize what hooks are triggered between state transitions:
-
-```mermaid
-stateDiagram-v2
-    direction LR
-    [*] --> Starting
-
-    state Starting {
-        direction LR
-
-        state "Needs clear storage?*" as NeedsClear
-        state "Is importing?" as IsImporting
-
-        NeedsClear --> Clearing : CLEAR
-        Clearing --> IsImporting
-        IsImporting --> Importing : IMPORT
-    }
-
-    Starting --> Started : START
-
-    state Started {
-        direction LR
-
-        state "Has seed?" as HasSeed
-
-        HasSeed --> Empty : No
-        HasSeed --> Locked : Yes
-
-        Empty --> Locked : CREATE \n---or---\nIMPORT
-
-        Locked --> Migrating : MIGRATE
-        Migrating --> Unlocked : UNLOCK
-        Unlocked --> Locked : LOCK
-
-        Unlocked --> Restarting : DELETE
-
-
-    }
-
-    Restarting --> [*] : RESTART
-
-    Started --> Started : LOAD
-
-    classDef conditional fill:#ededed,stroke:#c2c2c2,color:#a6a6a6,stroke-width:2;
-
-    class NeedsClear conditional
-    class IsImporting conditional
-    class HasSeed conditional
-```
-
-\* Wallet needs to clear storage if seed is not present or is restoring a new wallet
-
 ## Port
 
 Event bus between headless wallet and client
@@ -228,55 +148,6 @@ Currently not used.
 
 **Returns**: `boolean`
 
-## walletAccounts
-
-> Type: object
-
-| Method     | Type                                        | Description                                                    |
-| ---------- | ------------------------------------------- | -------------------------------------------------------------- |
-| create     | `async (walletAccountFields) => void`       | Creates a new WalletAccount with the provided fields.          |
-| update     | `async (name, walletAccountFields) => void` | Updates an existing WalletAccount with the provided fields.    |
-| enable     | `async (name) => void`                      | Enables an existing WalletAccount.                             |
-| disable    | `async (name) => void`                      | Disables an existing WalletAccount.                            |
-| getEnabled | `async () => object`                        | Returns enabled walletAccounts as `{ [name]: WalletAccount }`. |
-
-## blockchainMetadata
-
-> Type: object
-
-| Method                 | Type                                                                                                       | Description                                                                                              |
-| ---------------------- | ---------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
-| getTxLog               | `async ({ assetName, walletAccount }) => TxSet`                                                            | Get the TxSet for the provided `assetName`/`walletAccount` combination (AssetSource)                     |
-| getLoadedTxLogs        | `async () => object`                                                                                       | Get the all loaded `TxSet`s as a `{ [walletAccount]: { [assetName]: TxSet } } object`                    |
-| updateTxs              | `async ({ assetName: string, walletAccount: string, txs: object[] }) => void`                              | Add or update txs with updates provided in `txs`                                                         |
-| overwriteTxs           | `async ({ assetName: string, walletAccount: string, txs: object[], notifyReceivedTxs: ?boolean }) => void` | Overwrite specified txs.                                                                                 |
-| clearTxs               | `async ({ assetName: string, walletAccount: string }) => void`                                             | Remove txs for AssetSource.                                                                              |
-| removeTxs              | `async ({ assetName: string, walletAccount: string, txs: object[] }) => void`                              | Remove provided txs.                                                                                     |
-| getAccountState        | `async ({ assetName, walletAccount }) => AccountState`                                                     | Get the AccountState for the provided AssetSource                                                        |
-| getLoadedAccountStates | `async () => object`                                                                                       | Get the all loaded `AccountState`s as a `{ [walletAccount]: { [assetName]: AccountState } } object`      |
-| updateAccountState     | `async ({ assetName: string, walletAccount: string, newData: object }) => void`                            | Update accountState for AssetSource.                                                                     |
-| removeAccountState     | `async ({ assetName: string, walletAccount: string }) => void`                                             | Remove accountState for AssetSource.                                                                     |
-| batch                  | `() => Batch`                                                                                              | Create a batch of updates. See [blockchainMetadata](../blockchain-metadata) README for batching details. |
-
-## assets
-
-> Type: object
-
-| Method            | Type                                                       | Description                                                            |
-| ----------------- | ---------------------------------------------------------- | ---------------------------------------------------------------------- |
-| enable            | `async (assetNames: string[]) => void`                     | Enables assets.                                                        |
-| disable           | `async (assetNames: string[]) => void`                     | Disables assets.                                                       |
-| addAndEnableToken | `async (assetId: string, baseAssetName: string) => string` | Adds and enables a custom token. Returns the created `asset`'s `.name` |
-
-## locale
-
-> Type: object
-
-| Method      | Type                               | Description               |
-| ----------- | ---------------------------------- | ------------------------- |
-| setCurrency | `async (currency: string) => void` | Changes current currency. |
-| setLanguage | `async (language: string) => void` | Changes current language. |
-
 ## subscribe
 
 > Type: function

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@exodus/headless",
-  "version": "2.0.0-alpha.67",
-  "description": "The platform-agnostic Exodus wallet SDK",
-  "author": "Exodus Movement Inc.",
+  "version": "2.0.0-alpha.7",
+  "description": "The headless Exodus wallet SDK",
+  "author": "Exodus Movement Inc",
   "main": "src/index.js",
   "repository": {
     "type": "git",
@@ -17,78 +17,46 @@
     "src",
     "README.md",
     "CHANGELOG.md",
-    "!**/__tests__/**",
+    "!**/__tests__",
     "!**/*.test.js"
   ],
   "scripts": {
     "lint": "eslint . --ignore-path ../../.gitignore",
     "lint:fix": "yarn lint --fix",
-    "test": "jest --runInBand"
+    "test": "jest"
   },
   "dependencies": {
-    "@exodus/address-provider": "^6.0.0",
-    "@exodus/atoms": "^5.2.1",
-    "@exodus/auto-enable-assets-plugin": "^4.0.1",
-    "@exodus/available-assets": "^2.0.2",
-    "@exodus/balances": "^6.0.1",
+    "@exodus/atoms": "^2.9.0",
     "@exodus/basic-utils": "^2.0.0",
-    "@exodus/blockchain-metadata": "^8.1.0",
-    "@exodus/config": "^7.0.0",
-    "@exodus/dependency-injection": "^2.0.0",
-    "@exodus/dependency-preprocessors": "^2.8.2",
-    "@exodus/enabled-assets": "^6.0.2",
-    "@exodus/exodus-pricing-client": "^1.2.0",
-    "@exodus/feature-flags": "^2.2.0",
-    "@exodus/fee-monitors": "^1.0.0",
+    "@exodus/blockchain-metadata": "^8.0.1",
+    "@exodus/dependency-injection": "^1.2.0",
+    "@exodus/dependency-preprocessors": "^2.0.2",
     "@exodus/fetch": "^1.2.1",
-    "@exodus/fusion": "^6.0.0",
-    "@exodus/geolocation": "^2.0.1",
-    "@exodus/key-identifier-provider": "^1.1.3",
-    "@exodus/keychain": "^4.1.0",
-    "@exodus/market-history": "^5.0.0",
+    "@exodus/key-identifier-provider": "^1.1.1",
+    "@exodus/keychain": "^3.5.0",
     "@exodus/module": "^1.0.0",
-    "@exodus/nfts": "^2.1.1",
-    "@exodus/rates-monitor": "^2.0.1",
-    "@exodus/restore-progress-tracker": "^2.0.0",
-    "@exodus/wallet": "^6.3.0",
-    "@exodus/wallet-accounts": "^10.1.0",
+    "@exodus/wallet": "^6.0.0",
+    "@exodus/wallet-accounts": "^8.0.1",
     "@exodus/wallet-compatibility-modes": "^2.0.0",
-    "bip39": "^2.6.0",
-    "events": "^3.3.0",
-    "lodash": "npm:@exodus/lodash@^4.17.21-exodus.2",
+    "bip39": "2.6.0",
+    "lodash": "https://registry.yarnpkg.com/@exodus/lodash/-/lodash-4.17.21-exodus.2.tgz",
     "minimalistic-assert": "^1.0.1"
   },
   "devDependencies": {
-    "@exodus/ab-testing": "^6.0.0",
-    "@exodus/algorand-lib": "^2.0.1",
-    "@exodus/algorand-meta": "^1.1.4",
-    "@exodus/apy-rates": "^3.0.0",
-    "@exodus/bitcoin-lib": "^2.2.1",
     "@exodus/bitcoin-meta": "^1.0.0",
-    "@exodus/connected-origins": "^2.0.0",
-    "@exodus/crypto-news-monitor": "^3.0.0",
     "@exodus/currency": "^2.2.0",
     "@exodus/ethereum-lib": "^2.22.2",
     "@exodus/ethereum-meta": "^1.0.23",
-    "@exodus/kyc": "^4.0.0",
     "@exodus/models": "^8.11.1",
-    "@exodus/personal-notes": "^3.3.0",
-    "@exodus/referrals": "^6.2.0",
     "@exodus/solana-lib": "^1.3.11",
     "@exodus/solana-meta": "^1.0.2",
-    "@exodus/storage-encrypted": "^1.1.2",
-    "@exodus/storage-memory": "^2.1.0",
-    "@exodus/top-movers-monitor": "^3.0.0",
+    "@exodus/storage-encrypted": "^1.1.1",
+    "@exodus/storage-memory": "^1.1.0",
     "@exodus/wild-emitter": "^1.0.0",
     "buffer-json": "^2.0.0",
-    "deepmerge": "^4.2.2",
-    "delay": "^5.0.0",
-    "eslint": "^8.44.0",
-    "eslint-plugin-simple-import-sort": "^7.0.0",
-    "events": "^3.3.0",
+    "eslint": "^8.33.0",
     "jest": "^29.1.2",
-    "nock": "^13.3.1",
     "p-defer": "^4.0.0"
   },
-  "gitHead": "4854a1f2e047c7aa5ca5894fbb78a537e06901a3"
+  "gitHead": "8f74e04d3e7d18b5dac7ce2af8438f735c48353f"
 }

package/src/api.js

@@ -1,23 +1,56 @@
 import { validateMnemonic as isMnemonicValid } from 'bip39'
 
 const createApi = ({ ioc, port }) => {
-  const apis = ioc.getByType('api')
-  const { remoteConfig } = ioc.getByType('module')
-  const { feeMonitors, nftsMonitor } = ioc.getByType('monitor')
+  const { passphraseCache } = ioc.getByType('adapter')
 
-  // TODO: do this on 'unload'
-  const stop = () => {
-    remoteConfig.stop()
-    feeMonitors.stop()
-    nftsMonitor?.stop()
-  }
+  const { application, wallet, walletAccounts, blockchainMetadata } = ioc.getByType('module')
+  const { enabledWalletAccountsAtom } = ioc.getByType('atom')
 
   return {
-    ...Object.assign({}, ...Object.values(apis)),
+    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,
+    },
     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,18 +118,13 @@ 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] || []
 
     for (let i = 0; i < hooks.length; i++) {
-      try {
-        await hooks[i](params)
-      } catch (err) {
-        this._logger.error(`application lifecycle hook failed: ${hookName}`, hooks[i], params)
-        throw err
-      }
+      await hooks[i](params)
     }
 
     this.emit(hookName, params)
@@ -143,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) => {
@@ -163,16 +148,16 @@ class Application extends ExodusModule {
 
     const walletExists = await this.#wallet.exists()
 
-    const { forceRestart, forgotPassphrase, ...wallet } = opts
+    const { forceRestart, ...wallet } = opts
 
     await this.#wallet.import(wallet)
 
     if (forceRestart || walletExists) {
       await this.#storage.set(IMPORT_FLAG, true)
 
-      await this.fire(Hook.Restart, { reason: 'import' })
+      this.emit('restart', { reason: 'import' })
     } else {
-      await this.fire(Hook.Import)
+      await this.fire(HOOKS.import)
 
       this._logger.log('wallet imported')
     }
@@ -182,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) => {
@@ -191,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')
   }
@@ -200,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 () => {
@@ -219,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()
 
@@ -235,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()
 
@@ -251,14 +236,14 @@ 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')
   }
 
-  delete = async ({ forgotPassphrase } = {}) => {
+  delete = async () => {
     await this.#storage.set(DELETE_FLAG, true)
-    await this.fire(Hook.Restart, { reason: 'delete', forgotPassphrase })
+    this.emit('restart', { reason: 'delete' })
   }
 
   changeLockTimer = async ({ ttl }) => {

package/src/dependencies/atoms.js

@@ -1,5 +1,24 @@
-import baseAssetNamesToMonitorAtomDefinition from '../atoms/base-asset-names-to-monitor'
+import { createInMemoryAtom } from '@exodus/atoms'
+import {
+  walletAccountsAtomDefinition,
+  enabledWalletAccountsAtomDefinition,
+} from '@exodus/wallet-accounts/atoms'
+import { withType } from './utils'
 
-const createAtomDependencies = () => [{ definition: baseAssetNamesToMonitorAtomDefinition }]
+const createAtomDependencies = () =>
+  [
+    {
+      definition: {
+        id: 'lockedAtom',
+        factory: () => createInMemoryAtom({ defaultValue: true }),
+        dependencies: [],
+      },
+    },
+    {
+      definition: walletAccountsAtomDefinition,
+      storage: { namespace: 'walletAccounts' },
+    },
+    { definition: enabledWalletAccountsAtomDefinition },
+  ].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,11 +1,15 @@
+import { createKeychain } from '@exodus/keychain'
+import walletDefinition from '@exodus/wallet/module'
+import walletAccountsDefinition from '@exodus/wallet-accounts/module'
+import blockchainMetadataDefinition from '@exodus/blockchain-metadata/module'
 import createKeyIdentifierProvider from '@exodus/key-identifier-provider'
 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: {
@@ -21,10 +25,25 @@ const createModuleDependencies = ({ config }) =>
         dependencies: [],
       },
     },
+    {
+      definition: {
+        id: 'keychain',
+        factory: createKeychain,
+        dependencies: ['legacyPrivToPub'],
+      },
+    },
+    {
+      definition: walletDefinition,
+    },
     {
       definition: walletCompatibilityModesDefinition,
     },
     { definition: unlockEncryptedStorageDefinition },
+    { definition: walletAccountsDefinition },
+    {
+      definition: blockchainMetadataDefinition,
+      storage: { namespace: ['blockchain', 'v1'] },
+    },
   ].map(withType('module'))
 
 export default createModuleDependencies