@exodus/headless 2.0.0-alpha.5 → 2.0.0-alpha.51

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/address-provider/api.js

@@ -0,0 +1,14 @@
+const createAddressProviderApi = ({ addressProvider }) => ({
+  addressProvider: {
+    getAddress: addressProvider.getAddress.bind(addressProvider),
+    getSupportedPurposes: addressProvider.getSupportedPurposes.bind(addressProvider),
+    getReceiveAddress: addressProvider.getReceiveAddress.bind(addressProvider),
+  },
+})
+
+export default {
+  id: 'addressProviderApi',
+  type: 'api',
+  factory: createAddressProviderApi,
+  dependencies: ['addressProvider'],
+}

package/src/modules/address-provider/index.js

@@ -0,0 +1,15 @@
+import createAddressProviderDependencies from '@exodus/address-provider'
+
+import { withType } from '../../dependencies/utils'
+import addressProviderApi from './api'
+
+const addressProvider = ({ config }) => {
+  const dependencies = createAddressProviderDependencies(config).map(withType('module'))
+
+  return {
+    id: 'addressProvider',
+    definitions: [...dependencies, { definition: addressProviderApi }],
+  }
+}
+
+export default addressProvider

package/src/modules/apy-rates/index.js

@@ -0,0 +1,20 @@
+import { apyRatesAtomDefinition } from '@exodus/apy-rates/atoms'
+import apyRatesMonitorDefinition from '@exodus/apy-rates/monitor'
+
+import apyRatesPlugin from './plugin'
+
+const apyRates = () => {
+  return {
+    id: 'apyRates',
+    definitions: [
+      {
+        definition: apyRatesMonitorDefinition,
+        writesAtoms: ['apyRatesAtom'],
+      },
+      { definition: apyRatesAtomDefinition },
+      { definition: apyRatesPlugin },
+    ],
+  }
+}
+
+export default apyRates

package/src/modules/apy-rates/plugin.js

@@ -0,0 +1,14 @@
+const createApyRatesLifecyclePlugin = ({ apyRatesMonitor }) => {
+  const onUnlock = () => {
+    apyRatesMonitor.start()
+  }
+
+  return { onUnlock }
+}
+
+export default {
+  id: 'apyRatesLifecyclePlugin',
+  type: 'plugin',
+  factory: createApyRatesLifecyclePlugin,
+  dependencies: ['apyRatesMonitor'],
+}

package/src/modules/balances/index.js

@@ -0,0 +1,14 @@
+import { balancesAtomDefinition } from '@exodus/balances/atoms'
+import balancesDefinition from '@exodus/balances/module'
+
+const balances = () => {
+  return {
+    id: 'balances',
+    definitions: [
+      { definition: balancesDefinition, writesAtoms: ['balancesAtom'] },
+      { definition: balancesAtomDefinition },
+    ],
+  }
+}
+
+export default balances

package/src/modules/blockchain-metadata/api.js

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

package/src/modules/blockchain-metadata/index.js

@@ -0,0 +1,20 @@
+import blockchainMetadataDefinition from '@exodus/blockchain-metadata/module'
+
+import blockchainMetadataApiDefinition from './api'
+import blockchainMetadataPluginDefinition from './plugin'
+
+const blockchainMetadata = () => {
+  return {
+    id: 'blockchainMetadata',
+    definitions: [
+      {
+        definition: blockchainMetadataDefinition,
+        storage: { namespace: ['blockchain', 'v1'] },
+      },
+      { definition: blockchainMetadataPluginDefinition },
+      { definition: blockchainMetadataApiDefinition },
+    ],
+  }
+}
+
+export default blockchainMetadata

package/src/modules/blockchain-metadata/plugin.js

@@ -0,0 +1,30 @@
+import { createLoadWalletAccountsHandler } from './utils'
+
+const blockchainLifecyclePlugin = ({ blockchainMetadata, port }) => {
+  const handleLoadWalletAccounts = createLoadWalletAccountsHandler({ blockchainMetadata, port })
+
+  blockchainMetadata.on('load-wallet-accounts', handleLoadWalletAccounts)
+
+  blockchainMetadata.on('tx-logs-update', (payload) => port.emit('tx-logs-update', payload))
+
+  blockchainMetadata.on('account-states-update', (payload) =>
+    port.emit('account-states-update', payload)
+  )
+
+  const onUnlock = async () => {
+    await blockchainMetadata.load()
+  }
+
+  const onClear = async () => {
+    await blockchainMetadata.clear()
+  }
+
+  return { onUnlock, onClear }
+}
+
+export default {
+  id: 'blockchainLifecyclePlugin',
+  type: 'plugin',
+  factory: blockchainLifecyclePlugin,
+  dependencies: ['blockchainMetadata', 'port'],
+}

package/src/modules/blockchain-metadata/utils.js

@@ -0,0 +1,11 @@
+export function createLoadWalletAccountsHandler({ port, blockchainMetadata }) {
+  return async () => {
+    const [txLogs, accountStates] = await Promise.all([
+      blockchainMetadata.getLoadedTxLogs(),
+      blockchainMetadata.getLoadedAccountStates(),
+    ])
+
+    port.emit('tx-logs', txLogs)
+    port.emit('account-states', accountStates)
+  }
+}

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/crypto-news/index.js

@@ -0,0 +1,20 @@
+import { cryptoNewsAtomDefinition } from '@exodus/crypto-news-monitor/atoms'
+import cryptoNewsMonitorDefinition from '@exodus/crypto-news-monitor/monitor'
+
+import cryptoNewsPluginDefinition from './plugin'
+
+const cryptoNews = () => {
+  return {
+    id: 'cryptoNews',
+    definitions: [
+      { definition: cryptoNewsAtomDefinition },
+      {
+        definition: cryptoNewsMonitorDefinition,
+        writesAtoms: ['cryptoNewsAtom'],
+      },
+      { definition: cryptoNewsPluginDefinition },
+    ],
+  }
+}
+
+export default cryptoNews

package/src/modules/crypto-news/plugin.js

@@ -0,0 +1,17 @@
+const cryptoNewsPlugin = ({ cryptoNewsMonitor, featureFlagAtoms }) => {
+  const onUnlock = () => {
+    featureFlagAtoms.cryptoNews?.get().then(({ isOn }) => {
+      if (!isOn) return
+      cryptoNewsMonitor.start()
+    })
+  }
+
+  return { onUnlock }
+}
+
+export default {
+  id: 'cryptoNewsLifecyclePlugin',
+  type: 'plugin',
+  factory: cryptoNewsPlugin,
+  dependencies: ['cryptoNewsMonitor', 'featureFlagAtoms'],
+}

package/src/modules/enabled-assets/api.js

@@ -0,0 +1,18 @@
+const enabledAssetsApi = ({ enabledAssets, assetsModule }) => ({
+  assets: {
+    enable: enabledAssets.enable,
+    disable: enabledAssets.disable,
+    addAndEnableToken: async (...args) => {
+      const asset = await assetsModule.addToken(...args)
+      await enabledAssets.enable([asset.name])
+      return asset.name
+    },
+  },
+})
+
+export default {
+  id: 'enabledAssetsApi',
+  type: 'api',
+  factory: enabledAssetsApi,
+  dependencies: ['enabledAssets', 'assetsModule'],
+}

package/src/modules/enabled-assets/index.js

@@ -0,0 +1,26 @@
+import {
+  enabledAndDisabledAssetsAtomDefinition,
+  enabledAssetsAtomDefinition,
+} from '@exodus/enabled-assets/atoms'
+import enabledAssetsModuleDefinition from '@exodus/enabled-assets/module'
+
+import enabledAssetsApiDefinition from './api'
+import enabledAssetsPluginDefinition from './plugin'
+
+const enabledAssets = () => {
+  return {
+    id: 'enabledAssets',
+    definitions: [
+      { definition: enabledAssetsModuleDefinition, writesAtoms: ['enabledAndDisabledAssetsAtom'] },
+      {
+        definition: enabledAndDisabledAssetsAtomDefinition,
+        storage: { namespace: 'enabledAssets' },
+      },
+      { definition: enabledAssetsAtomDefinition },
+      { definition: enabledAssetsPluginDefinition },
+      { definition: enabledAssetsApiDefinition },
+    ],
+  }
+}
+
+export default enabledAssets

package/src/modules/enabled-assets/plugin.js

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

package/src/modules/feature-flags/api.js

@@ -0,0 +1,14 @@
+const featureFlagsApi = ({ featureFlagAtoms }) => ({
+  features: {
+    set: (feature, value) => featureFlagAtoms[feature]?.set({ isOn: value }),
+    enable: (feature) => featureFlagAtoms[feature]?.set({ isOn: true }),
+    disable: (feature) => featureFlagAtoms[feature]?.set({ isOn: false }),
+  },
+})
+
+export default {
+  id: 'featureFlagsApi',
+  type: 'api',
+  factory: featureFlagsApi,
+  dependencies: ['featureFlagAtoms'],
+}

package/src/modules/feature-flags/index.js

@@ -0,0 +1,37 @@
+import {
+  featureFlagAtomsDefinition,
+  featureFlagsAtomDefinition,
+  remoteConfigFeatureFlagAtomsDefinition,
+} from '@exodus/feature-flags/atoms'
+import featureFlagsDefinition from '@exodus/feature-flags/module'
+
+import featureFlagsApiDefinition from './api'
+import featureFlagsPluginDefinition from './plugin'
+
+const featureFlags = () => {
+  return {
+    id: 'featureFlags',
+    definitions: [
+      {
+        definition: featureFlagsDefinition,
+        writesAtoms: ['featureFlagAtoms'],
+      },
+      {
+        definition: featureFlagAtomsDefinition,
+        storage: { namespace: 'featureFlags' },
+        aliases: [
+          {
+            implementationId: 'unsafeStorage',
+            interfaceId: 'storage',
+          },
+        ],
+      },
+      { definition: featureFlagsAtomDefinition },
+      { definition: remoteConfigFeatureFlagAtomsDefinition },
+      { definition: featureFlagsPluginDefinition },
+      { definition: featureFlagsApiDefinition },
+    ],
+  }
+}
+
+export default featureFlags

package/src/modules/feature-flags/plugin.js

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

package/src/modules/fees/index.js

@@ -0,0 +1,16 @@
+import feeMonitorsDefinition from '@exodus/fee-monitors/monitor'
+
+import feesPlugin from './plugin'
+
+const fees = () => {
+  return {
+    id: 'fees',
+    definitions: [
+      // ...
+      { definition: feeMonitorsDefinition },
+      { definition: feesPlugin },
+    ],
+  }
+}
+
+export default fees

package/src/modules/fees/plugin.js

@@ -0,0 +1,17 @@
+const createFeesLifecyclePlugin = ({ feeMonitors, port }) => {
+  feeMonitors.on('fees-load', () => port.emit('fees-load', feeMonitors.getAllFeeData()))
+  feeMonitors.on('fees-update', (payload) => port.emit('fees-update', payload))
+
+  const onUnlock = () => {
+    feeMonitors.start()
+  }
+
+  return { onUnlock }
+}
+
+export default {
+  id: 'feesLifecyclePlugin',
+  type: 'plugin',
+  factory: createFeesLifecyclePlugin,
+  dependencies: ['feeMonitors', 'port'],
+}

package/src/modules/fiat-balances/index.js

@@ -0,0 +1,10 @@
+import nonDustBalanceAssetNamesAtomDefinition from './non-dust-balance-asset-names-atom'
+
+const fiatBalances = () => {
+  return {
+    id: 'fiatBalances',
+    definitions: [{ definition: nonDustBalanceAssetNamesAtomDefinition }],
+  }
+}
+
+export default fiatBalances

package/src/modules/fiat-balances/non-dust-balance-asset-names-atom.js

@@ -0,0 +1,10 @@
+import { createInMemoryAtom } from '@exodus/atoms'
+
+const nonDustBalanceAssetNamesAtomDefinition = {
+  id: 'nonDustBalanceAssetNamesAtom',
+  type: 'atom',
+  factory: () => createInMemoryAtom({ defaultValue: [] }),
+  dependencies: [],
+}
+
+export default nonDustBalanceAssetNamesAtomDefinition

package/src/modules/geolocation/index.js

@@ -0,0 +1,20 @@
+import { geolocationAtomDefinition } from '@exodus/geolocation/atoms'
+import geolocationMonitorDefinition from '@exodus/geolocation/monitor'
+
+import geolocationPluginDefinition from './plugin'
+
+const geolocation = () => {
+  return {
+    id: 'geolocation',
+    definitions: [
+      { definition: geolocationAtomDefinition },
+      {
+        definition: geolocationMonitorDefinition,
+        writesAtoms: ['geolocationAtom'],
+      },
+      { definition: geolocationPluginDefinition },
+    ],
+  }
+}
+
+export default geolocation

package/src/modules/geolocation/plugin.js

@@ -0,0 +1,14 @@
+const createGeolocationLifecyclePlugin = ({ geolocationMonitor }) => {
+  const onStart = async () => {
+    geolocationMonitor.start()
+  }
+
+  return { onStart }
+}
+
+export default {
+  id: 'geolocationLifecyclePlugin',
+  type: 'plugin',
+  factory: createGeolocationLifecyclePlugin,
+  dependencies: ['geolocationMonitor'],
+}

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,50 @@
+import { createStorageAtomFactory } from '@exodus/atoms'
+import { createFusionAtom } from '@exodus/fusion/atoms'
+
+import localeApiDefinition from './api'
+import localePluginDefinition from './plugin'
+
+const locale = () => {
+  return {
+    id: 'locale',
+    definitions: [
+      {
+        definition: {
+          id: 'currencyAtom',
+          type: 'atom',
+          factory: ({ fusion, config }) =>
+            createFusionAtom({
+              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, writesAtoms: ['languageAtom'] },
+      { definition: localeApiDefinition, writesAtoms: ['languageAtom', 'currencyAtom'] },
+    ],
+  }
+}
+
+export default locale