@exodus/headless 2.0.0-alpha.6 → 2.0.0-alpha.60

package/src/features/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/features/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/features/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/features/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/features/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/features/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/features/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/features/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/features/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/features/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/features/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/features/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/features/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/features/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/features/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/features/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/features/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

package/src/features/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/features/market-history/index.js

@@ -0,0 +1,66 @@
+import { createInMemoryAtom, createRemoteConfigAtomFactory } from '@exodus/atoms'
+import marketHistoryMonitorDefinition from '@exodus/market-history/module'
+
+import marketHistoryPluginDefinition from './plugin'
+
+const marketHistory = () => {
+  return {
+    id: 'marketHistory',
+    definitions: [
+      {
+        definition: { type: 'monitor', ...marketHistoryMonitorDefinition },
+        storage: { namespace: 'marketHistory' },
+        aliases: [
+          {
+            implementationId: 'unsafeStorage',
+            interfaceId: 'storage',
+          },
+          {
+            implementationId: 'marketHistoryClearCacheAtom',
+            interfaceId: 'clearCacheAtom',
+          },
+          {
+            implementationId: 'remoteConfigClearMarketHistoryCacheAtom',
+            interfaceId: 'remoteConfigClearCacheAtom',
+          },
+          {
+            implementationId: 'marketHistoryRefreshIntervalAtom',
+            interfaceId: 'remoteConfigRefreshIntervalAtom',
+          },
+        ],
+      },
+      // TODO: move to @exodus/market-history
+      {
+        definition: {
+          id: 'marketHistoryClearCacheAtom',
+          type: 'atom',
+          factory: ({ config }) => createInMemoryAtom(config),
+          dependencies: ['config'],
+        },
+      },
+      // TODO: move to @exodus/market-history
+      {
+        definition: {
+          id: 'remoteConfigClearMarketHistoryCacheAtom',
+          type: 'atom',
+          factory: ({ config, remoteConfig }) =>
+            createRemoteConfigAtomFactory({ remoteConfig })(config),
+          dependencies: ['config', 'remoteConfig'],
+        },
+      },
+      // TODO: move to @exodus/market-history
+      {
+        definition: {
+          id: 'marketHistoryRefreshIntervalAtom',
+          type: 'atom',
+          factory: ({ config, remoteConfig }) =>
+            createRemoteConfigAtomFactory({ remoteConfig })(config),
+          dependencies: ['config', 'remoteConfig'],
+        },
+      },
+      { definition: marketHistoryPluginDefinition },
+    ],
+  }
+}
+
+export default marketHistory

package/src/features/market-history/plugin.js

@@ -0,0 +1,21 @@
+const createMarketHistoryLifecyclePlugin = ({ marketHistory, port }) => {
+  // TODO: migrate to marketHistoryAtom. Will be easier once it's on headless
+  marketHistory.on('market-history', (payload) => port.emit('market-history', payload))
+
+  marketHistory.on('market-history-new-assets', (payload) =>
+    port.emit('market-history-new-assets', payload)
+  )
+
+  const onUnlock = () => {
+    marketHistory.start()
+  }
+
+  return { onUnlock }
+}
+
+export default {
+  id: 'marketHistoryLifecyclePlugin',
+  type: 'plugin',
+  factory: createMarketHistoryLifecyclePlugin,
+  dependencies: ['marketHistory', 'port'],
+}

package/src/features/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/features/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, writesAtoms: ['nftsCacheAtom', 'nftsConfigAtom'] },
+      { definition: nftsPluginDefinition },
+      { definition: nftsApiDefinition },
+    ],
+  }
+}
+
+export default nfts

package/src/features/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/features/pricing/api.js

@@ -0,0 +1,14 @@
+const pricingApi = ({ pricingClient }) => ({
+  pricing: {
+    currentPrice: pricingClient.currentPrice,
+    historicalPrice: pricingClient.historicalPrice,
+    ticker: pricingClient.ticker,
+  },
+})
+
+export default {
+  id: 'pricingApi',
+  type: 'api',
+  factory: pricingApi,
+  dependencies: ['pricingClient'],
+}

package/src/features/pricing/index.js

@@ -0,0 +1,35 @@
+import { createRemoteConfigAtomFactory } from '@exodus/atoms'
+import createExodusPricingClient from '@exodus/exodus-pricing-client'
+
+import pricingApi from './api'
+
+const pricing = () => {
+  return {
+    id: 'pricing',
+    definitions: [
+      {
+        definition: {
+          id: 'pricingClient',
+          type: 'module',
+          factory: createExodusPricingClient,
+          dependencies: ['fetch', 'pricingServerUrlAtom'],
+        },
+      },
+      {
+        definition: {
+          id: 'pricingServerUrlAtom',
+          type: 'atom',
+          factory: ({ config, remoteConfig }) =>
+            createRemoteConfigAtomFactory({ remoteConfig })({
+              path: config.pricingServerPath,
+              defaultValue: config.defaultPricingServerUrl,
+            }),
+          dependencies: ['config', 'remoteConfig'],
+        },
+      },
+      { definition: pricingApi },
+    ],
+  }
+}
+
+export default pricing

package/src/features/rates/api.js

@@ -0,0 +1,12 @@
+const ratesApi = ({ ratesMonitor }) => ({
+  rates: {
+    refresh: () => ratesMonitor.update(),
+  },
+})
+
+export default {
+  id: 'ratesApi',
+  type: 'api',
+  factory: ratesApi,
+  dependencies: ['ratesMonitor'],
+}

package/src/features/rates/index.js

@@ -0,0 +1,22 @@
+import { ratesAtomDefinition } from '@exodus/rates-monitor/atoms'
+import ratesMonitorDefinition from '@exodus/rates-monitor/module'
+
+import ratesApi from './api'
+import ratesPlugin from './plugin'
+
+const rates = () => {
+  return {
+    id: 'rates',
+    definitions: [
+      { definition: { type: 'atom', ...ratesAtomDefinition } },
+      {
+        definition: { type: 'monitor', ...ratesMonitorDefinition },
+        writesAtoms: ['ratesAtom'],
+      },
+      { definition: ratesPlugin },
+      { definition: ratesApi },
+    ],
+  }
+}
+
+export default rates

package/src/features/rates/plugin.js

@@ -0,0 +1,17 @@
+const createRatesLifecyclePlugin = ({ ratesMonitor, port }) => {
+  // TODO: migrate to ratesAtom. Will be easier once it's on headless
+  ratesMonitor.on('rates', (payload) => port.emit('rates', payload))
+
+  const onUnlock = () => {
+    ratesMonitor.start()
+  }
+
+  return { onUnlock }
+}
+
+export default {
+  id: 'ratesLifecyclePlugin',
+  type: 'plugin',
+  factory: createRatesLifecyclePlugin,
+  dependencies: ['ratesMonitor', 'port'],
+}

package/src/features/remote-config/api.js

@@ -0,0 +1,13 @@
+const createRemoteConfigApi = ({ remoteConfig }) => ({
+  remoteConfig: {
+    get: remoteConfig.get,
+    getAll: remoteConfig.getAll,
+  },
+})
+
+export default {
+  id: 'createRemoteConfigApi',
+  type: 'api',
+  factory: createRemoteConfigApi,
+  dependencies: ['remoteConfig'],
+}