@exodus/headless 2.0.0-alpha.1 → 2.0.0-alpha.10

package/CHANGELOG.md

@@ -3,6 +3,70 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.0.0-alpha.10](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.9...@exodus/headless@2.0.0-alpha.10) (2023-04-30)
+
+### Features
+
+- add pricingClient to headless ([#1439](https://github.com/ExodusMovement/exodus-hydra/issues/1439)) ([2a82a4c](https://github.com/ExodusMovement/exodus-hydra/commit/2a82a4c663b542178580908aaaff840524d55369))
+- attach wallet account atoms ([#1437](https://github.com/ExodusMovement/exodus-hydra/issues/1437)) ([2648699](https://github.com/ExodusMovement/exodus-hydra/commit/264869986c175091e6bc7c48e852946bd60911d6))
+
+## [2.0.0-alpha.9](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.8...@exodus/headless@2.0.0-alpha.9) (2023-04-26)
+
+### Features
+
+- add available-assets to headless ([#1361](https://github.com/ExodusMovement/exodus-hydra/issues/1361)) ([900d142](https://github.com/ExodusMovement/exodus-hydra/commit/900d142018ff112f36ef0f7ef53cf5020020e3ca))
+
+## [2.0.0-alpha.8](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.7...@exodus/headless@2.0.0-alpha.8) (2023-04-25)
+
+### Features
+
+- add enabled-assets to headless ([#1235](https://github.com/ExodusMovement/exodus-hydra/issues/1235)) ([a808b75](https://github.com/ExodusMovement/exodus-hydra/commit/a808b750bd911c33241ae710fbf8d8ba7e2073a6))
+- add lifecycle docs ([#1313](https://github.com/ExodusMovement/exodus-hydra/issues/1313)) ([df18faa](https://github.com/ExodusMovement/exodus-hydra/commit/df18faa9c341404c2feaadf51ec46236c54e2f15))
+- add remoteConfig module ([#1370](https://github.com/ExodusMovement/exodus-hydra/issues/1370)) ([ebc888d](https://github.com/ExodusMovement/exodus-hydra/commit/ebc888d6440c509a19dd6c9c600033fd41128ad7))
+- add support for plugins ([#1351](https://github.com/ExodusMovement/exodus-hydra/issues/1351)) ([fac0e2a](https://github.com/ExodusMovement/exodus-hydra/commit/fac0e2a727b0e71ad5f0619b8457c7e80612f707))
+
+## [2.0.0-alpha.7](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.6...@exodus/headless@2.0.0-alpha.7) (2023-04-24)
+
+### ⚠ BREAKING CHANGES
+
+- pass compatibility modes config to wallet (#1223)
+
+### Features
+
+- add blockchain metadata to headless ([#1293](https://github.com/ExodusMovement/exodus-hydra/issues/1293)) ([04390a7](https://github.com/ExodusMovement/exodus-hydra/commit/04390a71cb01744cd427f470735fa0748b9157ca))
+- add namespaceStorage preprocessor ([#1322](https://github.com/ExodusMovement/exodus-hydra/issues/1322)) ([95f403e](https://github.com/ExodusMovement/exodus-hydra/commit/95f403e59c87f90901247619c727496ebac0a399))
+- pass compatibility modes config to wallet ([#1223](https://github.com/ExodusMovement/exodus-hydra/issues/1223)) ([b49b640](https://github.com/ExodusMovement/exodus-hydra/commit/b49b64097af7969e210e5ecf5395ee7f40a13eac))
+
+## [2.0.0-alpha.6](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.5...@exodus/headless@2.0.0-alpha.6) (2023-04-20)
+
+### Features
+
+- add walletAccounts in headless ([#1184](https://github.com/ExodusMovement/exodus-hydra/issues/1184)) ([8d9c93d](https://github.com/ExodusMovement/exodus-hydra/commit/8d9c93d86173476211d596e883a72b51b645e866))
+
+## [2.0.0-alpha.5](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.4...@exodus/headless@2.0.0-alpha.5) (2023-04-20)
+
+### Features
+
+- force restart on import ([#1297](https://github.com/ExodusMovement/exodus-hydra/issues/1297)) ([3900196](https://github.com/ExodusMovement/exodus-hydra/commit/39001966ce7d962ddde9df8aa3b93619053569f8))
+- **headless:** clear storage when seed not present ([#1300](https://github.com/ExodusMovement/exodus-hydra/issues/1300)) ([c3c76f5](https://github.com/ExodusMovement/exodus-hydra/commit/c3c76f5953d91e5ef308b129f1bb2fec0dc41500))
+- unlock encrypted storage on wallet unlock ([#1304](https://github.com/ExodusMovement/exodus-hydra/issues/1304)) ([09ea5f2](https://github.com/ExodusMovement/exodus-hydra/commit/09ea5f20ff9547557f59d4c416cee3291f348fdf))
+
+## [2.0.0-alpha.4](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.3...@exodus/headless@2.0.0-alpha.4) (2023-04-13)
+
+**Note:** Version bump only for package @exodus/headless
+
+## [2.0.0-alpha.3](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.2...@exodus/headless@2.0.0-alpha.3) (2023-04-11)
+
+### Features
+
+- export subscribe/unsubscribe ([#1161](https://github.com/ExodusMovement/exodus-hydra/issues/1161)) ([7da465f](https://github.com/ExodusMovement/exodus-hydra/commit/7da465fc1734fd0818a55ff740704adb8c6ae222))
+
+## [2.0.0-alpha.2](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.1...@exodus/headless@2.0.0-alpha.2) (2023-04-10)
+
+### Features
+
+- restart reason ([#1163](https://github.com/ExodusMovement/exodus-hydra/issues/1163)) ([d2b10c7](https://github.com/ExodusMovement/exodus-hydra/commit/d2b10c71229078f52883badb5634b377c61b8b1e))
+
 ## [2.0.0-alpha.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0...@exodus/headless@2.0.0-alpha.1) (2023-04-05)
 
 ### Features

package/README.md

@@ -2,6 +2,15 @@
 
 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
@@ -34,15 +43,74 @@ const exodus = container.resolve()
 await exodus.wallet.create({ passphrase: 'my-super-secure-passphrase' })
 ```
 
+## 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
 
-| Method               | Type                                       | Description                                |
-| -------------------- | ------------------------------------------ | ------------------------------------------ |
-| subscribe            | `({ type: string, payload: any }) => void` | Subscribe to receive events.               |
-| unsubscribe(handler) | `({ type: string, payload: any }) => void` | Unsubscribe handler from receiving events. |
-| emit                 | `(type: string, payload: any) => void`     | Emit an event.                             |
+| Method      | Type                                       | Description                                |
+| ----------- | ------------------------------------------ | ------------------------------------------ |
+| subscribe   | `({ type: string, payload: any }) => void` | Subscribe to receive events.               |
+| unsubscribe | `({ type: string, payload: any }) => void` | Unsubscribe handler from receiving events. |
+| emit        | `(type: string, payload: any) => void`     | Emit an event.                             |
 
 ## Adapters
 
@@ -121,21 +189,21 @@ Currently not used.
 
 > Type: object
 
-| Method                   | Type                                                                    | Description                                                                       |
-| ------------------------ | ----------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
-| exists                   | `async () => boolean`                                                   | Checks if a wallet exists on the device.                                          |
-| create                   | `async ({ passphrase?: string }) => void`                               | Creates new wallet                                                                |
-| import                   | `async ({ mnemonic: string, passphrase?: string }) => void`             | Imports existing wallet                                                           |
-| delete                   | `async ({ passphrase?: string }) => void`                               | Deletes wallet. Passphrase is mandatory if wallet was created with one            |
-| lock                     | `async () => void`                                                      | Locks wallet                                                                      |
-| unlock                   | `async ({ passphrase?: string }) => void`                               | Unlocks wallet. Passphrase is mandatory if wallet was created with one            |
-| isLocked                 | `async () => boolean`                                                   | Checks if wallet is locked                                                        |
-| getMnemonic              | `async () => void`                                                      | Sets wallet as backed up                                                          |
-| changePassphrase         | `async ({ currentPassphrase?: string. newPassphrase: string }) => void` | Change passphrase. Current passphrase is mandatory if wallet was created with one |
-| restoreFromCurrentPhrase | `async ({ passphrase?: string }) => void`                               | Restore current wallet. Passphrase is mandatory if wallet was created with one    |
-| load                     | `async () => void`                                                      | Loads UI by rehydratating data through port (`BE Only`)                           |
-| unload                   | `async () => void`                                                      | Unloads UI by rehydratating data through port (`BE Only`)                         |
-| changeLockTimer          | `async ({ ttl: number }) => void`                                       | Change auto unlock ttl (`BE Only`)                                                |
+| Method                   | Type                                                                                | Description                                                                       |
+| ------------------------ | ----------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| exists                   | `async () => boolean`                                                               | Checks if a wallet exists on the device.                                          |
+| create                   | `async ({ passphrase?: string }) => void`                                           | Creates new wallet                                                                |
+| import                   | `async ({ mnemonic: string, passphrase?: string, forceRestart?: boolean }) => void` | Imports existing wallet                                                           |
+| delete                   | `async ({ passphrase?: string }) => void`                                           | Deletes wallet. Passphrase is mandatory if wallet was created with one            |
+| lock                     | `async () => void`                                                                  | Locks wallet                                                                      |
+| unlock                   | `async ({ passphrase?: string }) => void`                                           | Unlocks wallet. Passphrase is mandatory if wallet was created with one            |
+| isLocked                 | `async () => boolean`                                                               | Checks if wallet is locked                                                        |
+| getMnemonic              | `async () => void`                                                                  | Sets wallet as backed up                                                          |
+| changePassphrase         | `async ({ currentPassphrase?: string. newPassphrase: string }) => void`             | Change passphrase. Current passphrase is mandatory if wallet was created with one |
+| restoreFromCurrentPhrase | `async ({ passphrase?: string }) => void`                                           | Restore current wallet. Passphrase is mandatory if wallet was created with one    |
+| load                     | `async () => void`                                                                  | Loads UI by rehydratating data through port (`BE Only`)                           |
+| unload                   | `async () => void`                                                                  | Unloads UI by rehydratating data through port (`BE Only`)                         |
+| changeLockTimer          | `async ({ ttl: number }) => void`                                                   | Change auto unlock ttl (`BE Only`)                                                |
 
 ## isMnemonicValid
 
@@ -147,3 +215,52 @@ Currently not used.
 | wordlist | `string[]` | Words list to check against. |
 
 **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` |
+
+## subscribe
+
+> Type: function
+
+| Argument    | Type                                       | Description                                |
+| ----------- | ------------------------------------------ | ------------------------------------------ |
+| subscribe   | `({ type: string, payload: any }) => void` | Subscribe to receive events.               |
+| unsubscribe | `({ type: string, payload: any }) => void` | Unsubscribe handler from receiving events. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/headless",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.10",
   "description": "The headless Exodus wallet SDK",
   "author": "Exodus Movement Inc",
   "main": "src/index.js",
@@ -27,26 +27,42 @@
   },
   "dependencies": {
     "@exodus/atoms": "^2.9.0",
+    "@exodus/available-assets": "^2.0.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": "^5.0.4",
+    "@exodus/exodus-pricing-client": "^1.1.0",
     "@exodus/fetch": "^1.2.1",
-    "@exodus/key-identifier-provider": "^1.1.1",
-    "@exodus/keychain": "^3.2.1",
+    "@exodus/key-identifier-provider": "^1.1.3",
+    "@exodus/keychain": "^4.0.0",
     "@exodus/module": "^1.0.0",
-    "@exodus/wallet": "^5.0.0",
-    "@exodus/wallet-compatibility-modes": "1.0.2",
+    "@exodus/wallet": "^6.0.1",
+    "@exodus/wallet-accounts": "^8.0.1",
+    "@exodus/wallet-compatibility-modes": "^2.0.0",
     "bip39": "2.6.0",
+    "events": "^3.3.0",
     "lodash": "https://registry.yarnpkg.com/@exodus/lodash/-/lodash-4.17.21-exodus.2.tgz",
     "minimalistic-assert": "^1.0.1"
   },
   "devDependencies": {
+    "@exodus/bitcoin-meta": "^1.0.0",
+    "@exodus/currency": "^2.2.0",
     "@exodus/ethereum-lib": "^2.22.2",
+    "@exodus/ethereum-meta": "^1.0.23",
+    "@exodus/models": "^8.11.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/wild-emitter": "^1.0.0",
     "buffer-json": "^2.0.0",
     "eslint": "^8.33.0",
-    "jest": "^29.1.2"
+    "events": "^3.3.0",
+    "jest": "^29.1.2",
+    "p-defer": "^4.0.0"
   },
-  "gitHead": "885fc898545049d57c52696e9456aab6c2ecc1a2"
+  "gitHead": "468f15a295d9b9cd5463c33bbae6d3bb93028689"
 }

package/src/api.js

@@ -1,9 +1,19 @@
 import { validateMnemonic as isMnemonicValid } from 'bip39'
 
-const createApi = ({ ioc }) => {
+const createApi = ({ ioc, port }) => {
   const { passphraseCache } = ioc.getByType('adapter')
 
-  const { application, wallet } = ioc.getByType('module')
+  const {
+    application,
+    assetsModule,
+    blockchainMetadata,
+    enabledAssets,
+    remoteConfig,
+    wallet,
+    walletAccounts,
+  } = ioc.getByType('module')
+
+  const { enabledWalletAccountsAtom } = ioc.getByType('atom')
 
   return {
     wallet: {
@@ -27,7 +37,42 @@ const createApi = ({ ioc }) => {
       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,
+    },
     isMnemonicValid,
+    subscribe: port.subscribe.bind(port),
+    unsubscribe: port.unsubscribe.bind(port),
   }
 }
 

package/src/application.js

@@ -50,6 +50,7 @@ class Application extends ExodusModule {
     this.#storage = unsafeStorage.namespace('flags')
 
     this.#applicationStarted = new Promise((resolve) => (this.#resolveStart = resolve))
+    this.setMaxListeners(Number.POSITIVE_INFINITY)
   }
 
   start = async () => {
@@ -63,6 +64,11 @@ class Application extends ExodusModule {
     if (isDeleting || isImporting) {
       await this.#storage.batchDelete([DELETE_FLAG, IMPORT_FLAG])
       await this.#passphraseCache.clear()
+    }
+
+    const walletExists = await this.#wallet.exists()
+
+    if (isImporting || !walletExists) {
       await this.fire(HOOKS.clear)
     }
 
@@ -141,19 +147,21 @@ class Application extends ExodusModule {
 
     await this.#applicationStarted
 
-    if (await this.#wallet.exists()) {
-      await this.#wallet.import(opts)
-      await this.#storage.set(IMPORT_FLAG, true)
+    const walletExists = await this.#wallet.exists()
 
-      this.emit('restart')
+    const { forceRestart, ...wallet } = opts
 
-      return
-    }
+    await this.#wallet.import(wallet)
+
+    if (forceRestart || walletExists) {
+      await this.#storage.set(IMPORT_FLAG, true)
 
-    await this.#wallet.import(opts)
-    await this.fire(HOOKS.import)
+      this.emit('restart', { reason: 'import' })
+    } else {
+      await this.fire(HOOKS.import)
 
-    this._logger.log('wallet imported')
+      this._logger.log('wallet imported')
+    }
   }
 
   getMnemonic = async (opts) => this.#wallet.getMnemonic(opts)
@@ -236,7 +244,7 @@ class Application extends ExodusModule {
 
   delete = async () => {
     await this.#storage.set(DELETE_FLAG, true)
-    this.emit('restart')
+    this.emit('restart', { reason: 'delete' })
   }
 
   changeLockTimer = async ({ ttl }) => {

package/src/atoms/attach.js

@@ -0,0 +1,40 @@
+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 })
+    })
+  )
+
+  application.on('clear', async () => {
+    try {
+      await atom?.set(undefined)
+    } catch (error) {
+      logger.debug('failed to clear atom', error)
+      // noop. atom might not support set
+    }
+  })
+
+  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/constants.js

@@ -0,0 +1,6 @@
+export const atomsToAttach = [
+  //
+  'availableAssetNamesAtom',
+  'enabledWalletAccountsAtom',
+  'walletAccountsAtom',
+]

package/src/dependencies/atoms.js

@@ -1,4 +1,16 @@
-import { createInMemoryAtom } from '@exodus/atoms'
+import { createInMemoryAtom, createRemoteConfigAtomFactory } from '@exodus/atoms'
+import {
+  walletAccountsAtomDefinition,
+  enabledWalletAccountsAtomDefinition,
+} from '@exodus/wallet-accounts/atoms'
+
+import {
+  enabledAndDisabledAssetsAtomDefinition,
+  enabledAssetsAtomDefinition,
+} from '@exodus/enabled-assets/atoms'
+
+import { availableAssetNamesAtomDefinition } from '@exodus/available-assets/atoms'
+
 import { withType } from './utils'
 
 const createAtomDependencies = () =>
@@ -10,6 +22,25 @@ const createAtomDependencies = () =>
         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'],
+      },
+    },
   ].map(withType('atom'))
 
 export default createAtomDependencies

package/src/dependencies/index.js

@@ -8,6 +8,7 @@ import createAdapterDependencies from './adapters'
 import createAtomDependencies from './atoms'
 import createModuleDependencies from './modules'
 import { wrapConstant } from './utils'
+import createPluginDependencies from './plugins'
 
 const adapterKeys = [
   // ...
@@ -16,6 +17,9 @@ const adapterKeys = [
   'legacyPrivToPub',
   'seedStorage',
   'unsafeStorage',
+  'fusion',
+  'fetch',
+  'freeze',
 ]
 
 const createDependencies = ({ adapters, config }) => {
@@ -33,11 +37,14 @@ 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,10 +1,18 @@
-import { createKeychain } from '@exodus/keychain'
+import createRemoteConfig from '@exodus/config/remote'
+import keychainDefinition from '@exodus/keychain/module'
 import walletDefinition from '@exodus/wallet/module'
+import walletAccountsDefinition from '@exodus/wallet-accounts/module'
+import blockchainMetadataDefinition from '@exodus/blockchain-metadata/module'
+import enabledAssetsModuleDefinition from '@exodus/enabled-assets/module'
+import availableAssetsModuleDefinition from '@exodus/available-assets/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 { withType } from './utils'
+import unlockEncryptedStorageDefinition from '../unlock-encrypted-storage'
+import createExodusPricingClient from '@exodus/exodus-pricing-client'
 
 const createModuleDependencies = () =>
   [
@@ -23,11 +31,7 @@ const createModuleDependencies = () =>
       },
     },
     {
-      definition: {
-        id: 'keychain',
-        factory: createKeychain,
-        dependencies: ['legacyPrivToPub'],
-      },
+      definition: keychainDefinition,
     },
     {
       definition: walletDefinition,
@@ -35,6 +39,31 @@ const createModuleDependencies = () =>
     {
       definition: walletCompatibilityModesDefinition,
     },
+    { definition: unlockEncryptedStorageDefinition },
+    { definition: walletAccountsDefinition },
+    {
+      definition: blockchainMetadataDefinition,
+      storage: { namespace: ['blockchain', 'v1'] },
+    },
+    { definition: enabledAssetsModuleDefinition },
+    {
+      definition: {
+        id: 'remoteConfig',
+        factory: (deps) => {
+          const eventEmitter = new EventEmitter().setMaxListeners(Number.POSITIVE_INFINITY)
+          return createRemoteConfig({ eventEmitter, ...deps })
+        },
+        dependencies: ['fetch', 'freeze', 'config', 'logger'],
+      },
+    },
+    { definition: availableAssetsModuleDefinition },
+    {
+      definition: {
+        id: 'pricingClient',
+        factory: createExodusPricingClient,
+        dependencies: ['fetch', 'pricingServerUrlAtom'],
+      },
+    },
   ].map(withType('module'))
 
 export default createModuleDependencies

package/src/dependencies/plugins.js

@@ -0,0 +1,7 @@
+import plugins from '../plugins'
+import { withType } from './utils'
+
+const createPluginDependencies = () =>
+  plugins.map((definition) => ({ definition })).map(withType('plugin'))
+
+export default createPluginDependencies

package/src/index.js

@@ -1,35 +1,104 @@
+import { pick } from '@exodus/basic-utils'
 import createIOC from './ioc'
 import createApi from './api'
+import {
+  createAccountStatesUpdateHandler,
+  createLoadWalletAccountsHandler,
+} from './utils/blockchain-metadata'
+
+import attachPlugins from './plugins/attach'
+import attachAtoms from './atoms/attach'
+import { atomsToAttach } from './constants'
 
 const createExodus = ({ adapters, config, port }) => {
   const ioc = createIOC({ adapters, config })
+  const { headless: headlessConfig } = config
 
   const resolve = () => {
     ioc.resolve()
 
-    const { assetsModule } = ioc.getByType('adapter')
+    const { assetsModule, storage } = ioc.getByType('adapter')
+
+    const {
+      application,
+      blockchainMetadata,
+      enabledAssets,
+      remoteConfig,
+      unlockEncryptedStorage,
+      walletAccounts,
+    } = ioc.getByType('module')
+
+    const handleLoadWalletAccounts = createLoadWalletAccountsHandler({
+      blockchainMetadata,
+      port,
+      config,
+    })
+
+    const handleAccountStatesUpdate = createAccountStatesUpdateHandler({
+      blockchainMetadata,
+      port,
+      config,
+    })
+
+    blockchainMetadata.on('load-wallet-accounts', handleLoadWalletAccounts)
+    blockchainMetadata.on('tx-logs-update', (payload) => port.emit('tx-logs-update', payload))
+    blockchainMetadata.on('account-states-update', handleAccountStatesUpdate)
 
-    const { application } = ioc.getByType('module')
+    remoteConfig.on('sync', ({ current }) => port.emit('remote-config', current))
 
     application.hook('start', () => {
+      remoteConfig.load()
+
       port.emit('start')
     })
 
     application.hook('unlock', async () => {
+      if (typeof storage.unlock === 'function') unlockEncryptedStorage(storage)
+
+      remoteConfig.sync()
+
       await assetsModule.load()
+      await walletAccounts.load()
+      await Promise.all([
+        //
+        blockchainMetadata.load(),
+        enabledAssets.load(),
+      ])
+    })
+
+    application.on('unlock', () => {
+      port.emit('unlock')
     })
 
     application.hook('clear', async () => {
-      await Promise.all([assetsModule.clear()])
+      await Promise.all([
+        //
+        assetsModule.clear(),
+        walletAccounts.clear(),
+        blockchainMetadata.clear(),
+        enabledAssets.clear(),
+      ])
+
+      port.emit('clear')
+    })
+
+    application.on('restart', (payload) => {
+      port.emit('restart', payload)
     })
 
-    application.on('restart', () => {
-      port.emit('restart')
+    attachAtoms({
+      port,
+      application,
+      logger: ioc.get('createLogger')('attachAtoms'),
+      atoms: pick(ioc.getByType('atom'), atomsToAttach),
+      lifecycleEvents: headlessConfig?.attachAtomsLifecycleEvents,
     })
 
+    attachPlugins({ application, plugins: ioc.getByType('plugin') })
+
     application.start()
 
-    return createApi({ ioc })
+    return createApi({ ioc, port })
   }
 
   return { ...ioc, resolve }

package/src/ioc.js

@@ -3,6 +3,7 @@ import preprocess from '@exodus/dependency-preprocessors'
 import alias from '@exodus/dependency-preprocessors/src/preprocessors/alias'
 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 createDependencies from './dependencies'
 
@@ -11,7 +12,13 @@ const createIOC = ({ adapters, config }) => {
 
   const logger = createLogger('exodus:ioc')
   const dependencies = createDependencies({ adapters, config })
-  const preprocessors = [logify({ createLogger }), namespaceConfig(), alias()]
+  const preprocessors = [
+    logify({ createLogger }),
+    namespaceConfig(),
+    alias(),
+    // NOTE: order matters, this should come after `alias`
+    namespaceStorage(),
+  ]
   const definitions = preprocess({ dependencies, preprocessors })
   const ioc = createIocContainer({ logger })
 

package/src/plugins/attach.js

@@ -0,0 +1,19 @@
+import { kebabCase, memoize } from 'lodash'
+
+// e.g. onUnlock -> unlock -> onUnlock, onChangePassphrase -> change-passphrase
+const getApplicationHookName = memoize((lifecycleMethod) =>
+  kebabCase(lifecycleMethod.replace(/^on/, ''))
+)
+
+const attachPlugins = ({ plugins, application }) => {
+  Object.entries(plugins).forEach(([name, lifecycleMethods]) => {
+    const entries = Object.entries(lifecycleMethods || {})
+
+    for (const [lifecycleMethod, fn] of entries) {
+      const hookName = getApplicationHookName(lifecycleMethod)
+      application.hook(hookName, fn)
+    }
+  })
+}
+
+export default attachPlugins

package/src/plugins/index.js

@@ -0,0 +1,3 @@
+import logLifecyclePlugin from './log-lifecycle'
+
+export default [logLifecyclePlugin]

package/src/plugins/log-lifecycle.js

@@ -0,0 +1,25 @@
+const logLifecycle = {
+  id: 'logLifecyclePlugin',
+  type: 'plugin',
+  factory: ({ logger }) => {
+    return {
+      onLock: () => logger.debug('onLock'),
+      onUnlock: () => logger.debug('onUnlock'),
+      onClear: () => logger.debug('onClear'),
+      onImport: () => logger.debug('onImport'),
+      onMigrate: () => logger.debug('onMigrate'),
+      onStart: () => logger.debug('onStart'),
+      onLoad: () => logger.debug('onLoad'),
+      onUnload: () => logger.debug('onUnload'),
+      onCreate: () => logger.debug('onCreate'),
+      onBackup: () => logger.debug('onBackup'),
+      onRestore: () => logger.debug('onRestore'),
+      onRestoreCompleted: () => logger.debug('onRestoreCompleted'),
+      onAssetsSynced: () => logger.debug('onAssetsSynced'),
+      onChangePassphrase: () => logger.debug('onChangePassphrase'),
+    }
+  },
+  dependencies: ['logger'],
+}
+
+export default logLifecycle

package/src/unlock-encrypted-storage.js

@@ -0,0 +1,19 @@
+import { EXODUS_KEY_IDS } from '@exodus/keychain/module'
+
+const createUnlockEncryptedStorage = ({ keychain }) => {
+  return async (encryptedStorage) => {
+    // should the key id be part of a `config` dep?
+    const sodiumEncryptor = keychain.createSodiumEncryptor(EXODUS_KEY_IDS.WALLET_INFO)
+
+    await encryptedStorage.unlock({
+      encrypt: (data) => sodiumEncryptor.encryptSecretBox({ data }),
+      decrypt: (data) => sodiumEncryptor.decryptSecretBox({ data }),
+    })
+  }
+}
+
+export default {
+  id: 'unlockEncryptedStorage',
+  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))
+  }
+}