@exodus/headless 2.0.0-alpha.41 → 2.0.0-alpha.43

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 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.43](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.42...@exodus/headless@2.0.0-alpha.43) (2023-06-16)
+
+### Features
+
+- **headless:** integrate ab-testing module ([#1972](https://github.com/ExodusMovement/exodus-hydra/issues/1972)) ([6c063b4](https://github.com/ExodusMovement/exodus-hydra/commit/6c063b4d4f04d08c36f843577822e7d53f002d4f))
+
+## [2.0.0-alpha.42](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.41...@exodus/headless@2.0.0-alpha.42) (2023-06-15)
+
+### Features
+
+- .use poc using with kyc and referrals ([#1778](https://github.com/ExodusMovement/exodus-hydra/issues/1778)) ([7f66163](https://github.com/ExodusMovement/exodus-hydra/commit/7f66163364517fe555de220ad3cafd86c7c68516))
+- **headless:** use(nfts) ([#1963](https://github.com/ExodusMovement/exodus-hydra/issues/1963)) ([47ed141](https://github.com/ExodusMovement/exodus-hydra/commit/47ed141b93291938d8790a8697b55c9c9af230bd))
+- use() more modules ([#1953](https://github.com/ExodusMovement/exodus-hydra/issues/1953)) ([4f0d987](https://github.com/ExodusMovement/exodus-hydra/commit/4f0d987e2b3c01829e11b430988168754ebce8f6))
+
+### Bug Fixes
+
+- new use modules api export ([#1958](https://github.com/ExodusMovement/exodus-hydra/issues/1958)) ([c7e87eb](https://github.com/ExodusMovement/exodus-hydra/commit/c7e87eb01f5fb79fcc3454a11485dadf638f88ef))
+- remove duplicated kyc api ([#1955](https://github.com/ExodusMovement/exodus-hydra/issues/1955)) ([3357590](https://github.com/ExodusMovement/exodus-hydra/commit/33575908517230b5a187f0ac3b6e32e75982abdb))
+- require plugin methods to be declared correctly ([#1945](https://github.com/ExodusMovement/exodus-hydra/issues/1945)) ([e7feae6](https://github.com/ExodusMovement/exodus-hydra/commit/e7feae6cfaa3cd0e9f9d074f4b5306a264d16b74))
+
 ## [2.0.0-alpha.41](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/headless@2.0.0-alpha.40...@exodus/headless@2.0.0-alpha.41) (2023-06-15)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/headless",
-  "version": "2.0.0-alpha.41",
+  "version": "2.0.0-alpha.43",
   "description": "The headless Exodus wallet SDK",
   "author": "Exodus Movement Inc",
   "main": "src/index.js",
@@ -26,6 +26,7 @@
     "test": "jest --runInBand"
   },
   "dependencies": {
+    "@exodus/ab-testing": "^5.1.0",
     "@exodus/address-provider": "^4.0.0",
     "@exodus/apy-rates": "^2.1.0",
     "@exodus/atoms": "^4.0.1",
@@ -87,5 +88,5 @@
     "nock": "^13.3.1",
     "p-defer": "^4.0.0"
   },
-  "gitHead": "c548938b8c6dee498023373e2122cb95da1005f5"
+  "gitHead": "67ed7c439d9d3626db03d8c926af3e1fbe19cf8f"
 }

package/src/api.js

@@ -1,45 +1,34 @@
 import { validateMnemonic as isMnemonicValid } from 'bip39'
 
 const createApi = ({ ioc, port }) => {
+  const apis = ioc.getByType('api')
+
   const { assetsModule } = 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()
+    nftsMonitor?.stop()
   }
 
   return {
+    ...Object.assign({}, ...Object.values(apis)),
     wallet: {
       exists: () => wallet.exists(),
       start: application.start,
@@ -62,13 +51,6 @@ 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,
@@ -95,10 +77,6 @@ const createApi = ({ ioc, port }) => {
       get: remoteConfig.get,
       getAll: remoteConfig.getAll,
     },
-    locale: {
-      setLanguage: (value) => languageAtom.set(value),
-      setCurrency: (value) => currencyAtom.set(value),
-    },
     rates: {
       refresh: () => ratesMonitor.update(),
     },
@@ -107,36 +85,9 @@ const createApi = ({ ioc, port }) => {
       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),

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 {

package/src/constants.js

@@ -1,4 +1,5 @@
 export const atomsToAttach = [
+  'abTestingAtom',
   'apyRatesAtom',
   'availableAssetNamesAtom',
   'balancesAtom',
@@ -16,3 +17,20 @@ export const atomsToAttach = [
   'topMoversAtom',
   'walletAccountsAtom',
 ]
+
+export const LifecycleHook = 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',
+})

package/src/dependencies/atoms.js

@@ -1,13 +1,11 @@
 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,
@@ -15,16 +13,9 @@ import {
 } 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'
@@ -40,11 +31,6 @@ const createAtomDependencies = () =>
         dependencies: [],
       },
     },
-    {
-      definition: walletAccountsAtomDefinition,
-      storage: { namespace: 'walletAccounts' },
-    },
-    { definition: enabledWalletAccountsAtomDefinition },
     {
       definition: enabledAndDisabledAssetsAtomDefinition,
       storage: { namespace: 'enabledAssets' },
@@ -65,36 +51,6 @@ const createAtomDependencies = () =>
         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: {
@@ -144,8 +100,6 @@ const createAtomDependencies = () =>
     { definition: ratesAtomDefinition },
     { definition: geolocationAtomDefinition },
     { definition: featureFlagsAtomDefinition },
-    { definition: kycAtomDefinition },
-    { definition: referralsAtomDefinition },
     {
       definition: personalNotesAtomDefinition,
       aliases: [
@@ -155,30 +109,11 @@ const createAtomDependencies = () =>
         },
       ],
     },
-    {
-      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/modules.js

@@ -3,18 +3,13 @@ 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 walletDefinition from '@exodus/wallet/module'
-import walletAccountsDefinition from '@exodus/wallet-accounts/module'
 import walletCompatibilityModesDefinition from '@exodus/wallet-compatibility-modes/module'
 import EventEmitter from 'events/'
 
@@ -49,7 +44,6 @@ const createModuleDependencies = ({ config }) =>
       definition: walletCompatibilityModesDefinition,
     },
     { definition: unlockEncryptedStorageDefinition },
-    { definition: walletAccountsDefinition, writesAtoms: ['walletAccountsAtom'] },
     {
       definition: blockchainMetadataDefinition,
       storage: { namespace: ['blockchain', 'v1'] },
@@ -79,31 +73,9 @@ const createModuleDependencies = ({ config }) =>
       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: nftsModuleDefinition,
-    },
   ].map(withType('module'))
 
 export default createModuleDependencies

package/src/dependencies/monitors.js

@@ -3,7 +3,6 @@ import cryptoNewsMonitorDefinition from '@exodus/crypto-news-monitor/monitor'
 import feeMonitorsDefinition from '@exodus/fee-monitors/monitor'
 import geolocationMonitorDefinition from '@exodus/geolocation/monitor'
 import marketHistoryMonitorDefinition from '@exodus/market-history/module'
-import nftsMonitorDefinition from '@exodus/nfts/monitor'
 import ratesMonitorDefinition from '@exodus/rates-monitor/module'
 import localTopMoversMonitorDefinition from '@exodus/top-movers-monitor/monitor/local'
 import remoteTopMoversMonitorDefinition from '@exodus/top-movers-monitor/monitor/remote'
@@ -57,10 +56,6 @@ const createMonitorDependencies = ({ config }) =>
       definition: apyRatesMonitorDefinition,
       writesAtoms: ['apyRatesAtom'],
     },
-    {
-      definition: nftsMonitorDefinition,
-      writesAtoms: ['nftsCacheAtom'],
-    },
   ].map(withType('monitor'))
 
 export default createMonitorDependencies

package/src/index.js

@@ -4,6 +4,13 @@ import createApi from './api'
 import attachAtoms from './atoms/attach'
 import { atomsToAttach } from './constants'
 import createIOC from './ioc'
+import abTesting from './modules/ab-testing'
+import connectedOrigins from './modules/connected-origins'
+import kyc from './modules/kyc'
+import locale from './modules/locale'
+import nfts from './modules/nfts'
+import referrals from './modules/referrals'
+import walletAccounts from './modules/wallet-accounts'
 import attachPlugins from './plugins/attach'
 import { createLoadWalletAccountsHandler } from './utils/blockchain-metadata'
 
@@ -11,26 +18,29 @@ const createExodus = ({ adapters, config, port }) => {
   const ioc = createIOC({ adapters, config })
   const { headless: headlessConfig } = config
 
+  ioc.use(walletAccounts())
+  ioc.use(locale())
+  ioc.use(nfts())
+  ioc.use(kyc())
+  ioc.use(referrals())
+  ioc.use(connectedOrigins())
+  ioc.use(abTesting())
+
+  ioc.register({ definition: { id: 'port', type: 'port', factory: () => port } })
+
   const resolve = () => {
     ioc.resolve()
 
     const { assetsModule, storage } = ioc.getByType('adapter')
 
-    const { languageAtom } = ioc.getByType('atom')
-
     const {
       application,
       blockchainMetadata,
-      connectedOrigins,
       enabledAssets,
       featureFlags,
-      kyc,
-      nfts,
       personalNotes,
-      referrals,
       remoteConfig,
       unlockEncryptedStorage,
-      walletAccounts,
     } = ioc.getByType('module')
 
     const {
@@ -39,7 +49,6 @@ const createExodus = ({ adapters, config, port }) => {
       feeMonitors,
       geolocationMonitor,
       marketHistory,
-      nftsMonitor,
       ratesMonitor,
       topMoversMonitor,
     } = ioc.getByType('monitor')
@@ -71,9 +80,6 @@ const createExodus = ({ adapters, config, port }) => {
     // TODO: migrate to ratesAtom. Will be easier once it's on headless
     ratesMonitor.on('rates', (payload) => port.emit('rates', payload))
 
-    nftsMonitor.on('nfts', (data) => port.emit('nfts', data))
-    nftsMonitor.on('nfts-txs', (data) => port.emit('nfts-txs', data))
-
     application.hook('start', (payload) => {
       remoteConfig.load()
       featureFlags.load()
@@ -90,23 +96,14 @@ const createExodus = ({ adapters, config, port }) => {
       ratesMonitor.start()
       feeMonitors.start()
       apyRatesMonitor.start()
-      nftsMonitor.start()
 
       await assetsModule.load()
-      await connectedOrigins.load()
-      await walletAccounts.load()
       await Promise.all([
         //
         blockchainMetadata.load(),
         enabledAssets.load(),
       ])
 
-      featureFlagAtoms.referrals?.get().then(({ isOn }) => {
-        if (!isOn) return
-        kyc.load()
-        referrals.load()
-      })
-
       featureFlagAtoms.topMovers?.get().then(({ isOn }) => {
         if (!isOn) return
         topMoversMonitor.start()
@@ -126,18 +123,16 @@ const createExodus = ({ adapters, config, port }) => {
       await Promise.all([
         //
         assetsModule.clear(),
-        walletAccounts.clear(),
         blockchainMetadata.clear(),
         enabledAssets.clear(),
-        connectedOrigins.clear(),
         featureFlags.clear(),
-        languageAtom.set(undefined),
       ])
 
       // TEMP: dont wait to clear as encrypted storage is not yet unlocked
       personalNotes.clear()
-      nfts.clear()
+    })
 
+    application.on('clear', () => {
       port.emit('clear')
     })
 
@@ -153,7 +148,11 @@ const createExodus = ({ adapters, config, port }) => {
       lifecycleEvents: headlessConfig?.attachAtomsLifecycleEvents,
     })
 
-    attachPlugins({ application, plugins: ioc.getByType('plugin') })
+    attachPlugins({
+      application,
+      plugins: ioc.getByType('plugin'),
+      logger: ioc.get('createLogger')('attachPlugins'),
+    })
 
     return createApi({ ioc, port })
   }

package/src/ioc.js

@@ -15,7 +15,6 @@ const createIOC = ({ adapters, config }) => {
   const { readOnlyAtoms: readOnlyAtomsConfig, devModeAtoms: devModeAtomsConfig } = config.ioc ?? {}
 
   const ioc = createIocContainer({ logger: createLogger('exodus:ioc') })
-  const dependencies = createDependencies({ adapters, config })
 
   const preprocessors = [
     logify({ createLogger }),
@@ -40,9 +39,13 @@ const createIOC = ({ adapters, config }) => {
     registerMultiple([dependency])
   }
 
-  registerMultiple(dependencies)
+  const use = (module) => {
+    registerMultiple(module.definitions)
+  }
+
+  registerMultiple(createDependencies({ adapters, config }))
 
-  return { ...ioc, register, registerMultiple }
+  return { ...ioc, register, registerMultiple, use }
 }
 
 export default createIOC

package/src/modules/ab-testing/api.js

@@ -0,0 +1,13 @@
+const abTestingApi = ({ abTesting }) => ({
+  abTesting: {
+    trackEvent: abTesting.trackEvent,
+    updateVariant: abTesting.updateVariant,
+  },
+})
+
+export default {
+  id: 'abTestingApi',
+  type: 'api',
+  factory: abTestingApi,
+  dependencies: ['abTesting'],
+}

package/src/modules/ab-testing/index.js

@@ -0,0 +1,26 @@
+import { abTestingAtomDefinition } from '@exodus/ab-testing/atoms'
+import abTestingDefinition from '@exodus/ab-testing/module'
+
+import abTestingApiDefinition from './api'
+import abTestingPluginDefinition from './plugin'
+
+const abTesting = () => {
+  return {
+    id: 'abTesting',
+    definitions: [
+      {
+        definition: abTestingAtomDefinition,
+        storage: { namespace: 'abTesting' },
+        aliases: [{ implementationId: 'unsafeStorage', interfaceId: 'storage' }],
+      },
+      {
+        definition: abTestingDefinition,
+        writesAtom: ['abTestingAtom'],
+      },
+      { definition: abTestingPluginDefinition },
+      { definition: abTestingApiDefinition },
+    ],
+  }
+}
+
+export default abTesting

package/src/modules/ab-testing/plugin.js

@@ -0,0 +1,21 @@
+const abTestingLifecyclePlugin = ({ abTesting, featureFlagAtoms }) => {
+  const onStart = async () => {
+    featureFlagAtoms.abTesting?.get().then(({ isOn }) => {
+      if (!isOn) return
+      abTesting.load()
+    })
+  }
+
+  const onClear = async () => {
+    await abTesting.clear()
+  }
+
+  return { onStart, onClear }
+}
+
+export default {
+  id: 'abTestingLifecyclePlugin',
+  type: 'plugin',
+  factory: abTestingLifecyclePlugin,
+  dependencies: ['abTesting', 'featureFlagAtoms'],
+}

package/src/modules/connected-origins/api.js

@@ -0,0 +1,23 @@
+const connectedOriginsApi = ({ connectedOrigins, connectedOriginsAtom }) => ({
+  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,
+  },
+})
+
+export default {
+  id: 'connectedOriginsApi',
+  type: 'api',
+  factory: connectedOriginsApi,
+  dependencies: ['connectedOrigins', 'connectedOriginsAtom'],
+}

package/src/modules/connected-origins/index.js

@@ -0,0 +1,31 @@
+import { connectedOriginsAtomDefinition } from '@exodus/connected-origins/atoms'
+import connectedOriginsDefinition from '@exodus/connected-origins/module'
+
+import connectedOriginsApiDefinition from './api'
+import connectedOriginsPluginDefinition from './plugin'
+
+const connectedOrigins = () => {
+  return {
+    id: 'connectedOrigins',
+    definitions: [
+      {
+        definition: connectedOriginsAtomDefinition,
+        storage: { namespace: 'connectedOrigins' },
+        aliases: [
+          {
+            implementationId: 'unsafeStorage',
+            interfaceId: 'storage',
+          },
+        ],
+      },
+      {
+        definition: connectedOriginsDefinition,
+        writesAtoms: ['connectedOriginsAtom'],
+      },
+      { definition: connectedOriginsPluginDefinition },
+      { definition: connectedOriginsApiDefinition },
+    ],
+  }
+}
+
+export default connectedOrigins

package/src/modules/connected-origins/plugin.js

@@ -0,0 +1,18 @@
+const connectedOriginsPlugin = ({ connectedOrigins }) => {
+  const onUnlock = async () => {
+    await connectedOrigins.load()
+  }
+
+  const onClear = async () => {
+    await connectedOrigins.clear()
+  }
+
+  return { onUnlock, onClear }
+}
+
+export default {
+  id: 'connectedOriginsLifecyclePlugin',
+  type: 'plugin',
+  factory: connectedOriginsPlugin,
+  dependencies: ['connectedOrigins'],
+}

package/src/modules/kyc/api.js

@@ -0,0 +1,14 @@
+const kycApi = ({ kyc }) => ({
+  kyc: {
+    start: kyc.start,
+    sync: kyc.sync,
+    requestKycToken: kyc.requestKycToken,
+  },
+})
+
+export default {
+  id: 'kycApi',
+  type: 'api',
+  factory: kycApi,
+  dependencies: ['kyc'],
+}

package/src/modules/kyc/index.js

@@ -0,0 +1,19 @@
+import { kycAtomDefinition } from '@exodus/kyc/atoms'
+import kycDefinition from '@exodus/kyc/module'
+
+import kycApi from './api'
+import kycPlugin from './plugin'
+
+const kyc = () => {
+  return {
+    id: 'kyc',
+    definitions: [
+      { definition: kycAtomDefinition },
+      { definition: kycDefinition, writesAtoms: ['kycAtom'] },
+      { definition: kycPlugin },
+      { definition: kycApi },
+    ],
+  }
+}
+
+export default kyc

package/src/modules/kyc/plugin.js

@@ -0,0 +1,21 @@
+const kycPlugin = ({ kyc, featureFlagAtoms }) => {
+  const onUnlock = () => {
+    featureFlagAtoms.referrals?.get().then(({ isOn }) => {
+      if (!isOn) return
+      kyc.load()
+    })
+  }
+
+  const onUnload = () => {
+    kyc.stop()
+  }
+
+  return { onUnlock, onUnload }
+}
+
+export default {
+  id: 'kycLifecyclePlugin',
+  type: 'plugin',
+  factory: kycPlugin,
+  dependencies: ['kyc', 'featureFlagAtoms'],
+}

package/src/modules/locale/api.js

@@ -0,0 +1,13 @@
+const localeApi = ({ languageAtom, currencyAtom }) => ({
+  locale: {
+    setLanguage: (value) => languageAtom.set(value),
+    setCurrency: (value) => currencyAtom.set(value),
+  },
+})
+
+export default {
+  id: 'localeApi',
+  type: 'api',
+  factory: localeApi,
+  dependencies: ['languageAtom', 'currencyAtom'],
+}

package/src/modules/locale/index.js

@@ -0,0 +1,48 @@
+import { createFusionAtomFactory, createStorageAtomFactory } from '@exodus/atoms'
+
+import localeApiDefinition from './api'
+import localePluginDefinition from './plugin'
+
+const locale = () => {
+  return {
+    id: 'locale',
+    definitions: [
+      {
+        definition: {
+          id: 'currencyAtom',
+          type: 'atom',
+          factory: ({ fusion, config }) =>
+            createFusionAtomFactory({ fusion })({
+              path: `private.currency`,
+              defaultValue: config.defaultValue,
+            }),
+          dependencies: ['fusion', 'config'],
+        },
+      },
+      {
+        definition: {
+          id: 'languageAtom',
+          type: 'atom',
+          factory: ({ storage, config }) =>
+            createStorageAtomFactory({ storage })({
+              key: 'language',
+              defaultValue: config.defaultValue,
+              isSoleWriter: true,
+            }),
+          dependencies: ['storage', 'config'],
+        },
+        aliases: [
+          {
+            implementationId: 'unsafeStorage',
+            interfaceId: 'storage',
+          },
+        ],
+        storage: { namespace: 'locale' },
+      },
+      { definition: localePluginDefinition },
+      { definition: localeApiDefinition },
+    ],
+  }
+}
+
+export default locale

package/src/modules/locale/plugin.js

@@ -0,0 +1,14 @@
+const localePlugin = ({ languageAtom }) => {
+  const onClear = async () => {
+    await languageAtom.set(undefined)
+  }
+
+  return { onClear }
+}
+
+export default {
+  id: 'localeLifecyclePlugin',
+  type: 'plugin',
+  factory: localePlugin,
+  dependencies: ['languageAtom'],
+}

package/src/modules/nfts/api.js

@@ -0,0 +1,13 @@
+const createNftsApi = ({ nfts, nftsMonitor }) => ({
+  nfts: {
+    upsertConfig: nfts.upsertConfig,
+    setMonitorInterval: nftsMonitor.setInterval,
+  },
+})
+
+export default {
+  id: 'createNftsApi',
+  type: 'api',
+  factory: createNftsApi,
+  dependencies: ['nfts', 'nftsMonitor'],
+}

package/src/modules/nfts/index.js

@@ -0,0 +1,33 @@
+import { nftsCacheAtomDefinition, nftsConfigsAtomDefinition } from '@exodus/nfts/atoms'
+import nftsModuleDefinition from '@exodus/nfts/module'
+import nftsMonitorDefinition from '@exodus/nfts/monitor'
+
+import nftsApiDefinition from './api'
+import nftsPluginDefinition from './plugin'
+
+// TODO: Add type to module definitions
+const nfts = () => {
+  return {
+    id: 'nfts',
+    definitions: [
+      {
+        definition: { type: 'atom', ...nftsCacheAtomDefinition },
+        storage: { namespace: 'nftsCache' },
+      },
+      {
+        definition: { type: 'atom', ...nftsConfigsAtomDefinition },
+        aliases: [{ implementationId: 'unsafeStorage', interfaceId: 'storage' }],
+        storage: { namespace: 'nfts-config' },
+      },
+      {
+        definition: { type: 'monitor', ...nftsMonitorDefinition },
+        writesAtoms: ['nftsCacheAtom'],
+      },
+      { definition: nftsModuleDefinition },
+      { definition: nftsPluginDefinition },
+      { definition: nftsApiDefinition },
+    ],
+  }
+}
+
+export default nfts

package/src/modules/nfts/plugin.js

@@ -0,0 +1,23 @@
+const nftsLifecyclePlugin = ({ nfts, nftsMonitor, port }) => {
+  // TODO: Move to onStart, but needs testing first
+  nftsMonitor.on('nfts', (data) => port.emit('nfts', data))
+  nftsMonitor.on('nfts-txs', (data) => port.emit('nfts-txs', data))
+
+  const onUnlock = () => {
+    nfts.load()
+    nftsMonitor.start()
+  }
+
+  const onClear = () => {
+    nfts.clear()
+  }
+
+  return { onUnlock, onClear }
+}
+
+export default {
+  id: 'nftsLifecyclePlugin',
+  type: 'plugin',
+  factory: nftsLifecyclePlugin,
+  dependencies: ['nfts', 'nftsMonitor', 'port'],
+}

package/src/modules/referrals/api.js

@@ -0,0 +1,13 @@
+const referralsApi = ({ referrals }) => ({
+  referrals: {
+    setReferredBy: referrals.setReferredBy,
+    referralCodeExists: referrals.referralCodeExists,
+  },
+})
+
+export default {
+  id: 'referralsApi',
+  type: 'api',
+  factory: referralsApi,
+  dependencies: ['referrals'],
+}

package/src/modules/referrals/index.js

@@ -0,0 +1,28 @@
+import { referralsAtomDefinition } from '@exodus/referrals/atoms'
+import referralsDefinition from '@exodus/referrals/module'
+
+import referralsApi from './api'
+import referralsPlugin from './plugin'
+
+const unsafeStorageAlias = { implementationId: 'unsafeStorage', interfaceId: 'storage' }
+
+const referrals = ({ namespace = 'referrals', useUnsafeStorage = true } = {}) => {
+  const aliases = useUnsafeStorage ? [unsafeStorageAlias] : []
+
+  return {
+    id: 'referrals',
+    definitions: [
+      { definition: referralsAtomDefinition },
+      {
+        definition: referralsDefinition,
+        storage: { namespace },
+        writesAtoms: ['referralsAtom'],
+        aliases,
+      },
+      { definition: referralsPlugin },
+      { definition: referralsApi },
+    ],
+  }
+}
+
+export default referrals

package/src/modules/referrals/plugin.js

@@ -0,0 +1,21 @@
+const referralsPlugin = ({ referrals, featureFlagAtoms }) => {
+  const onUnlock = () => {
+    featureFlagAtoms.referrals?.get().then(({ isOn }) => {
+      if (!isOn) return
+      referrals.load()
+    })
+  }
+
+  const onUnload = () => {
+    referrals.stop()
+  }
+
+  return { onUnlock, onUnload }
+}
+
+export default {
+  id: 'referralsLifecyclePlugin',
+  type: 'plugin',
+  factory: referralsPlugin,
+  dependencies: ['referrals', 'featureFlagAtoms'],
+}

package/src/modules/wallet-accounts/api.js

@@ -0,0 +1,16 @@
+const walletAccountsApi = ({ walletAccounts, enabledWalletAccountsAtom }) => ({
+  walletAccounts: {
+    create: walletAccounts.create,
+    update: walletAccounts.update,
+    disable: walletAccounts.disable,
+    enable: walletAccounts.enable,
+    getEnabled: enabledWalletAccountsAtom.get,
+  },
+})
+
+export default {
+  id: 'walletAccountsApi',
+  type: 'api',
+  factory: walletAccountsApi,
+  dependencies: ['walletAccounts', 'enabledWalletAccountsAtom'],
+}

package/src/modules/wallet-accounts/index.js

@@ -0,0 +1,29 @@
+import {
+  enabledWalletAccountsAtomDefinition,
+  walletAccountsAtomDefinition,
+} from '@exodus/wallet-accounts/atoms'
+import walletAccountsDefinition from '@exodus/wallet-accounts/module'
+
+import walletAccountsApiDefinition from './api'
+import walletAccountsPluginDefinition from './plugin'
+
+const walletAccounts = () => {
+  return {
+    id: 'walletAccounts',
+    definitions: [
+      {
+        definition: walletAccountsDefinition,
+        writesAtoms: ['walletAccountsAtom'],
+      },
+      {
+        definition: walletAccountsAtomDefinition,
+        storage: { namespace: 'walletAccounts' },
+      },
+      { definition: enabledWalletAccountsAtomDefinition },
+      { definition: walletAccountsApiDefinition },
+      { definition: walletAccountsPluginDefinition },
+    ],
+  }
+}
+
+export default walletAccounts

package/src/modules/wallet-accounts/plugin.js

@@ -0,0 +1,18 @@
+const walletAccountsPlugin = ({ walletAccounts }) => {
+  const onUnlock = async () => {
+    await walletAccounts.load()
+  }
+
+  const onClear = async () => {
+    await walletAccounts.clear()
+  }
+
+  return { onUnlock, onClear }
+}
+
+export default {
+  id: 'walletAccountsLifecyclePlugin',
+  type: 'plugin',
+  factory: walletAccountsPlugin,
+  dependencies: ['walletAccounts'],
+}

package/src/plugins/attach.js

@@ -1,17 +1,23 @@
-import { kebabCase, memoize } from 'lodash'
+import { LifecycleHook } from '../constants'
 
-// e.g. onUnlock -> unlock -> onUnlock, onChangePassphrase -> change-passphrase
-const getApplicationHookName = memoize((lifecycleMethod) =>
-  kebabCase(lifecycleMethod.replace(/^on/, ''))
+const LIFECYCLE_METHOD_TO_HOOK_NAME = Object.fromEntries(
+  Object.entries(LifecycleHook).map(([pascalCaseName, hookName]) => [
+    `on${pascalCaseName}`,
+    hookName,
+  ])
 )
 
-const attachPlugins = ({ plugins, application }) => {
+const attachPlugins = ({ plugins, application, logger }) => {
   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)
+      const hookName = LIFECYCLE_METHOD_TO_HOOK_NAME[lifecycleMethod]
+      if (hookName) {
+        application.hook(hookName, fn)
+      } else {
+        logger.error(`plugin "${name}" declares unsupported lifecycle method "${lifecycleMethod}"`)
+      }
     }
   })
 }