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

package/src/constants.js

@@ -1,36 +0,0 @@
-export const atomsToAttach = [
-  'abTestingAtom',
-  'apyRatesAtom',
-  'availableAssetNamesAtom',
-  'balancesAtom',
-  'connectedOriginsAtom',
-  'cryptoNewsAtom',
-  'currencyAtom',
-  'enabledWalletAccountsAtom',
-  'featureFlagsAtom',
-  'geolocationAtom',
-  'kycAtom',
-  'languageAtom',
-  'nftsConfigAtom',
-  'personalNotesAtom',
-  'referralsAtom',
-  '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/plugins.js

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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,
-        writesAtoms: ['abTestingAtom'],
-      },
-      { definition: abTestingPluginDefinition },
-      { definition: abTestingApiDefinition },
-    ],
-  }
-}
-
-export default abTesting

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

@@ -1,21 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

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

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

@@ -1,22 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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/feature-flags/index.js

@@ -1,35 +0,0 @@
-import {
-  featureFlagAtomsDefinition,
-  featureFlagsAtomDefinition,
-  remoteConfigFeatureFlagAtomsDefinition,
-} from '@exodus/feature-flags/atoms'
-import featureFlagsDefinition from '@exodus/feature-flags/module'
-
-import featureFlagsPlugin 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: featureFlagsPlugin },
-    ],
-  }
-}
-
-export default featureFlags

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

@@ -1,18 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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/geolocation/index.js

@@ -1,20 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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/modules/locale/plugin.js

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