@exodus/market-history 1.0.0 → 2.0.0

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## 1.1.0 (2023-01-24)
+
+### Features
+
+- add #/config per-key events ([#303](https://github.com/ExodusMovement/exodus-hydra/issues/303)) ([5391435](https://github.com/ExodusMovement/exodus-hydra/commit/539143598da10966ec18a93d9200542565682ecf))
+- add `restricted-imports` eslint rule ([#719](https://github.com/ExodusMovement/exodus-hydra/issues/719)) ([175de9c](https://github.com/ExodusMovement/exodus-hydra/commit/175de9c19ec00e5a12441022c313837d58f38882))
+- add market history monitor ([#206](https://github.com/ExodusMovement/exodus-hydra/issues/206)) ([121f026](https://github.com/ExodusMovement/exodus-hydra/commit/121f0268f2a3c5cb0a6a4b2788947714740a8c21))
+- immediately show portfolio chart ([#1877](https://github.com/ExodusMovement/exodus-hydra/issues/1877)) ([ed6d9f6](https://github.com/ExodusMovement/exodus-hydra/commit/ed6d9f6e3daa3195fa6de1b91487315ac3282489))
+- prevent monitors from running multiple times ([#497](https://github.com/ExodusMovement/exodus-hydra/issues/497)) ([81238ca](https://github.com/ExodusMovement/exodus-hydra/commit/81238cacaf893cb5019b5e02c481bcace1193f43))
+- use real fusion sync in config ([#258](https://github.com/ExodusMovement/exodus-hydra/issues/258)) ([56f351c](https://github.com/ExodusMovement/exodus-hydra/commit/56f351cc18942499b47b5b3afecafaf181c2989b)), closes [#262](https://github.com/ExodusMovement/exodus-hydra/issues/262)
+
+### Bug Fixes
+
+- do not load rates on initial currency load ([#1548](https://github.com/ExodusMovement/exodus-hydra/issues/1548)) ([2eb5713](https://github.com/ExodusMovement/exodus-hydra/commit/2eb5713fe53ce3816a0857e917c1de6df91a15b2))
+- do sync if started on start ([#766](https://github.com/ExodusMovement/exodus-hydra/issues/766)) ([1f19664](https://github.com/ExodusMovement/exodus-hydra/commit/1f19664bb8839328e6bb6ec9c9e965f78d8ae86b))
+- fetch market-history prices for all assets, not only solana ([#829](https://github.com/ExodusMovement/exodus-hydra/issues/829)) ([36aa1d5](https://github.com/ExodusMovement/exodus-hydra/commit/36aa1d5dffb3773722bd930202be7c521fb71579))
+- missing await ([#748](https://github.com/ExodusMovement/exodus-hydra/issues/748)) ([3f6b527](https://github.com/ExodusMovement/exodus-hydra/commit/3f6b527e04b7224324e9a2462c361a5c79816146))
+- start monitors on popup re-open ([#249](https://github.com/ExodusMovement/exodus-hydra/issues/249)) ([2b6d257](https://github.com/ExodusMovement/exodus-hydra/commit/2b6d257eb5fd625801a695f6579b114509869750))
+- use new sync event for local-config change ([#302](https://github.com/ExodusMovement/exodus-hydra/issues/302)) ([2042801](https://github.com/ExodusMovement/exodus-hydra/commit/2042801293b30f3347949f5bd687f665c7fa4ee9))
+
+### Performance Improvements
+
+- send less data from market prices module ([#1451](https://github.com/ExodusMovement/exodus-hydra/issues/1451)) ([eef3673](https://github.com/ExodusMovement/exodus-hydra/commit/eef3673c2dab332f4b1f071a001fccb0977b02c7))

package/README.md

@@ -6,19 +6,24 @@ returns prices on interval `close`.
 ## Install
 
 ```sh
-yarn add @exodus/@exodus/market-history
+yarn add @exodus/market-history
 ```
 
 ## Usage
 
 ```js
-import createMarketHistoryMonitor from '@exodus/market-history'
+import createMarketHistoryMonitor from '@exodus/market-history/module'
 
-const marketHistoryMonitor = createMarketHistoryMonitor({
+const marketHistoryMonitor = createMarketHistoryMonitor.factory({
   assetsModule,
   currencyAtom,
   storage: marketHistoryStorage,
-  pricingServer,
+  pricingClient,
+  getCacheKey: ({ currency, assetName, granularity }) =>
+    `prices-${currency}-${assetName}-${granularity}`, // optional
+  remoteConfigRefreshIntervalAtom, // optional
+  clearCacheAtom, // optional. set value if you want to clear cache.
+  remoteConfigClearCacheAtom, // optional. If you want to clear cache set any value in this atom.
 })
 
 marketHistoryMonitor.on('market-history', ({ currency, granularity, prices }) => {

package/module/index.js

@@ -0,0 +1,296 @@
+import { mapValues, SynchronizedTime } from '@exodus/basic-utils'
+import ExodusModule from '@exodus/module'
+import { fetchHistoricalPrices, fetchPricesInterval } from '@exodus/price-api'
+import ms from 'ms'
+
+import { getAssetFromTicker, getAssetTickers, parseGranularity } from '../utils'
+import { createInMemoryAtom, difference } from '@exodus/atoms'
+
+const CLEAR_MARKET_HISTORY_CACHE_KEY = 'clear-market-history-cache'
+const CLEAR_MARKET_HISTORY_CACHE_FROM_REMOTE_CONFIG_KEY =
+  'clear-market-history-cache-from-remote-config'
+const MARKET_HISTORY_REFRESH_KEY = 'market-history-cache-refresh'
+
+const transformPriceEntries = (entries = []) => {
+  const closePrices = entries.map((entry) => [entry[0], entry[1].close])
+  return Object.fromEntries(closePrices)
+}
+
+const transformPricesByAssetName = (pricesByAssetName) =>
+  mapValues(pricesByAssetName, (entries) => transformPriceEntries(entries))
+
+// when provided cache version from local or remote config is different from stored on device we clear the cache and fetch new prices
+const _invalidateStorageCache = async ({
+  storage,
+  clearRuntimeCache,
+  clearCacheVersion,
+  remoteConfigClearCacheVersion,
+}) => {
+  const clearCacheVersionInStorage = await storage.get(CLEAR_MARKET_HISTORY_CACHE_KEY)
+  const clearCacheFromRemoteConfigVersionInStorage = await storage.get(
+    CLEAR_MARKET_HISTORY_CACHE_FROM_REMOTE_CONFIG_KEY
+  )
+  const localAreEqual = !clearCacheVersion || clearCacheVersionInStorage === clearCacheVersion
+  const remoteAreEqual =
+    !remoteConfigClearCacheVersion ||
+    clearCacheFromRemoteConfigVersionInStorage === remoteConfigClearCacheVersion
+
+  if (localAreEqual && remoteAreEqual) return // we already cleared cache
+
+  await storage.clear()
+  clearRuntimeCache()
+
+  return Promise.all([
+    storage
+      .set(CLEAR_MARKET_HISTORY_CACHE_KEY, clearCacheVersion || '')
+      .catch((e) => console.warn(e)),
+    storage
+      .set(CLEAR_MARKET_HISTORY_CACHE_FROM_REMOTE_CONFIG_KEY, remoteConfigClearCacheVersion || '')
+      .catch((e) => console.warn(e)),
+  ])
+}
+
+const getCacheKeyDefault = ({ currency, assetName, granularity }) =>
+  `prices-${currency}-${assetName}-${granularity}`
+
+const MODULE_ID = 'marketHistory'
+
+class MarketHistoryMonitor extends ExodusModule {
+  #pricingClient
+  #currencyAtom
+  #currency = null
+  #getCacheKey = getCacheKeyDefault
+  #remoteConfigRefreshIntervalAtom = null
+  #clearCacheAtom = null
+  #remoteConfigClearCacheAtom = null
+  #runtimeCache = new Map()
+
+  constructor({
+    assetsModule,
+    storage,
+    currencyAtom,
+    pricingClient,
+    getCacheKey = getCacheKeyDefault,
+    remoteConfigRefreshIntervalAtom = null,
+    clearCacheAtom = createInMemoryAtom({ defaultValue: null }),
+    remoteConfigClearCacheAtom = createInMemoryAtom({ defaultValue: null }),
+  }) {
+    super({ name: 'MarketHistoryMonitor' })
+
+    this.assetsModule = assetsModule
+    this.storage = storage
+    this.#pricingClient = pricingClient
+    this.#getCacheKey = getCacheKey
+    this.#remoteConfigRefreshIntervalAtom = remoteConfigRefreshIntervalAtom
+    this.#clearCacheAtom = clearCacheAtom
+    this.#remoteConfigClearCacheAtom = remoteConfigClearCacheAtom
+    this.#currencyAtom = currencyAtom
+  }
+
+  #started = false
+
+  #setCache = async ({ currency, granularity, pricesByAssetName }) => {
+    const changes = Object.keys(pricesByAssetName).reduce((acc, assetName) => {
+      const key = this.#getCacheKey({ currency, assetName, granularity })
+      const values = pricesByAssetName[assetName]
+      if (values.length > 0) {
+        acc[key] = values
+        this.#runtimeCache.set(key, values)
+      }
+      return acc
+    }, {})
+
+    await this.storage.batchSet(changes)
+  }
+
+  #getCache = async ({ currency, granularity, assetName }) => {
+    const key = this.#getCacheKey({ currency, assetName, granularity })
+    const cachedValue = this.#runtimeCache.get(key)
+    if (cachedValue) {
+      return cachedValue
+    }
+    const cache = (await this.storage.get(key)) || []
+    this.#runtimeCache.set(key, cache)
+
+    return cache
+  }
+
+  #getRuntimeCacheKey = ({ fiatTicker, granularity, assetTicker }) =>
+    this.#getCacheKey({
+      currency: fiatTicker,
+      granularity,
+      assetName: getAssetFromTicker(this.assetsModule.getAssets(), assetTicker).name,
+    })
+
+  #fetch = async ({ currency, granularity }) => {
+    const assets = this.assetsModule.getAssets()
+    const assetTickers = getAssetTickers(assets)
+
+    const cacheRefreshData = (await this.storage.get(MARKET_HISTORY_REFRESH_KEY)) || {}
+
+    const cacheRefreshKey = `${granularity}-${currency}`
+    const latestRefreshTimestamp = cacheRefreshData[cacheRefreshKey] || 0
+    const refreshIntervalMs = this.#remoteConfigRefreshIntervalAtom
+      ? await this.#remoteConfigRefreshIntervalAtom.get()
+      : null
+    const ignoreCache =
+      !!refreshIntervalMs &&
+      !Number.isNaN(refreshIntervalMs) &&
+      SynchronizedTime.now() - latestRefreshTimestamp > refreshIntervalMs
+    if (ignoreCache) {
+      cacheRefreshData[cacheRefreshKey] = SynchronizedTime.now()
+      await this.storage.set(MARKET_HISTORY_REFRESH_KEY, cacheRefreshData)
+    }
+
+    const { fetchedPricesMap } = await fetchHistoricalPrices({
+      api: (...args) => this.#pricingClient.historicalPrice(...args),
+      assetTickers,
+      fiatTicker: currency,
+      granularity,
+      ignoreInvalidSymbols: true,
+      getCurrentTime: SynchronizedTime.now,
+      getCacheFromStorage: async (ticker) =>
+        this.#getCache({
+          currency,
+          granularity,
+          assetName: getAssetFromTicker(assets, ticker)?.name,
+        }),
+      ignoreCache,
+      runtimeCache: this.#runtimeCache,
+      getRuntimeCacheKey: ({ fiatTicker, granularity, assetTicker }) =>
+        this.#getRuntimeCacheKey({ fiatTicker, granularity, assetTicker }),
+    })
+
+    const pricesByAssetName = mapValues(assets, (asset) => {
+      const assetPricesMap = fetchedPricesMap.get(asset.ticker)
+      return assetPricesMap ? [...assetPricesMap] : []
+    })
+
+    this.#setCache({ currency, granularity, pricesByAssetName })
+
+    return transformPricesByAssetName(pricesByAssetName)
+  }
+
+  update = async (granularity) => {
+    const parsedGranularity = parseGranularity(granularity)
+    const currency = this.#currency
+
+    try {
+      const prices = await this.#fetch({ currency, granularity })
+      this.emit('market-history', { currency, granularity: parsedGranularity, prices })
+    } catch (error) {
+      console.error(
+        'MarketHistoryMonitor: Failed to fetch rates',
+        currency,
+        parsedGranularity,
+        error
+      )
+    }
+  }
+
+  #updateAll = () => {
+    return Promise.all([this.update('hour'), this.update('day')])
+  }
+
+  #syncGranularity = async (granularity) => {
+    const parsedGranularity = parseGranularity(granularity)
+    const currency = this.#currency
+    const assets = this.assetsModule.getAssets()
+
+    const cachedPricesByAssetName = Object.fromEntries(
+      Object.keys(assets).map((assetName) => {
+        const key = this.#getCacheKey({ currency, assetName, granularity })
+        return [assetName, this.#runtimeCache.get(key)]
+      })
+    )
+
+    const prices = transformPricesByAssetName(cachedPricesByAssetName)
+    this.emit('market-history', { currency, granularity: parsedGranularity, prices })
+  }
+
+  sync = async () => {
+    this.#syncGranularity('day')
+    this.#syncGranularity('hour')
+  }
+
+  invalidateStorage = async ({ remoteConfigClearCacheVersion }) => {
+    const clearCacheVersion = await this.#clearCacheAtom.get() // don't think we need to observe it considering this runs only on startup and set manually in config
+    return _invalidateStorageCache({
+      storage: this.storage,
+      clearRuntimeCache: () => {
+        this.#runtimeCache = new Map()
+      },
+      clearCacheVersion,
+      remoteConfigClearCacheVersion,
+    })
+  }
+
+  #listenRemoteConfigClearCacheVersionChanges = () => {
+    difference(this.#remoteConfigClearCacheAtom).observe(async ({ current, previous }) => {
+      if (previous !== undefined && current !== previous) {
+        await this.invalidateStorage({ remoteConfigClearCacheVersion: current })
+        await this.#updateAll()
+      }
+    })
+  }
+
+  #setupTimers = () => {
+    const jitter = ms('3s')
+    const getCurrentTime = SynchronizedTime.now
+    const updateDayPrices = this.update.bind(this, 'day')
+    const updateHourPrices = this.update.bind(this, 'hour')
+
+    fetchPricesInterval({
+      func: updateDayPrices,
+      granularity: 'day',
+      jitter,
+      getCurrentTime,
+    })
+
+    fetchPricesInterval({
+      func: updateHourPrices,
+      granularity: 'hour',
+      jitter,
+      getCurrentTime,
+    })
+  }
+
+  start = async () => {
+    if (this.#started) {
+      await this.sync()
+      return
+    }
+
+    this.#started = true
+
+    const remoteConfigClearCacheVersion = await this.#remoteConfigClearCacheAtom.get()
+    await this.invalidateStorage({ remoteConfigClearCacheVersion })
+    this.#listenRemoteConfigClearCacheVersionChanges()
+
+    await this.#currencyAtom.observe((currency) => {
+      if (this.#currency) {
+        this.#currency = currency
+        this.#updateAll()
+      } else {
+        this.#currency = currency
+        this.#setupTimers()
+      }
+    })
+  }
+}
+
+const createMarketHistoryMonitor = (args = {}) => new MarketHistoryMonitor({ ...args })
+
+export default {
+  id: MODULE_ID,
+  factory: createMarketHistoryMonitor,
+  dependencies: [
+    'pricingClient',
+    'currencyAtom',
+    'storage',
+    'assetsModule',
+    'clearCacheAtom',
+    'remoteConfigClearCacheAtom',
+    'remoteConfigRefreshIntervalAtom',
+  ],
+}

package/package.json

@@ -1,30 +1,37 @@
 {
   "name": "@exodus/market-history",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "module to fetch historical prices for assets",
   "author": "Exodus Movement Inc",
   "license": "UNLICENSED",
   "scripts": {
-    "lint": "eslint .",
+    "lint": "eslint . --ignore-path ../../.gitignore",
     "lint:fix": "yarn lint --fix",
     "test": "jest"
   },
   "files": [
-    "index.js",
-    "utils.js"
+    "module",
+    "utils.js",
+    "CHANGELOG.md",
+    "README.md",
+    "!**/__tests__"
   ],
   "dependencies": {
     "@exodus/basic-utils": "^1.0.0",
-    "@exodus/module": "^1.0.0",
-    "@exodus/price-api": "^2.0.11",
+    "@exodus/module": "^1.1.0",
+    "@exodus/price-api": "^3.2.1",
     "ms": "^0.7.1"
   },
   "devDependencies": {
     "@exodus/assets": "^8.0.72",
-    "@exodus/atoms": "^1.0.0",
-    "@exodus/storage-memory": "^1.0.0"
+    "@exodus/atoms": "^2.3.0",
+    "@exodus/storage-memory": "^1.0.0",
+    "eslint": "^8.33.0",
+    "events": "^3.3.0",
+    "jest": "^29.1.2"
   },
   "peerDependencies": {
     "debug": ">= 3.0.0"
-  }
-}
+  },
+  "gitHead": "37c209ea7fe3d24bc78fbb530f738a8ff3a87723"
+}

package/utils.js

@@ -3,8 +3,17 @@ export const getAssetTickers = (assets) =>
     .map((asset) => asset.ticker)
     .sort()
 
-export const getAssetFromTicker = (assets, ticker) =>
-  Object.values(assets).find((asset) => asset.ticker === ticker)
+let assetFromTickerCache = {}
+export const getAssetFromTicker = (assets, ticker) => {
+  if (assetFromTickerCache[ticker]) return assetFromTickerCache[ticker]
+  return Object.values(assets).find((asset) => {
+    if (asset.ticker === ticker) {
+      assetFromTickerCache[ticker] = asset
+      return true
+    }
+    return false
+  })
+}
 
 export const parseGranularity = (granularity) => {
   switch (granularity) {

package/index.js

@@ -1,171 +0,0 @@
-import { mapValues, SynchronizedTime } from '@exodus/basic-utils'
-import ExodusModule from '@exodus/module'
-import { fetchHistoricalPrices, fetchPricesInterval } from '@exodus/price-api'
-import ms from 'ms'
-
-import { getAssetFromTicker, getAssetTickers, parseGranularity } from './utils'
-
-const MARKET_HISTORY_CACHE_VERSION = 'v1'
-
-const transformPriceEntries = (entries = []) => {
-  const closePrices = entries.map((entry) => [entry[0], entry[1].close])
-  return Object.fromEntries(closePrices)
-}
-
-const transformPricesByAssetName = (pricesByAssetName) =>
-  mapValues(pricesByAssetName, (entries) => transformPriceEntries(entries))
-
-class MarketHistoryMonitor extends ExodusModule {
-  #pricingServer
-  #currencyAtom
-  #previousCurrency = null
-
-  constructor({ assetsModule, storage, currencyAtom, pricingServer }) {
-    super({ name: 'MarketHistoryMonitor' })
-
-    this.assetsModule = assetsModule
-    this.storage = storage
-    this.#pricingServer = pricingServer
-
-    this.#currencyAtom = currencyAtom
-    this.#currencyAtom.observe((value) => value && this.#onCurrencyChange(value))
-  }
-
-  #started = false
-
-  #onCurrencyChange = async (value) => {
-    if (this.#previousCurrency === null) {
-      this.#previousCurrency = value
-      return
-    }
-
-    this.#update('day')
-    this.#update('hour')
-
-    this.#previousCurrency = value
-  }
-
-  #getCacheKey = ({ currency, assetName, granularity }) => {
-    return `${currency}-${assetName}-${granularity}-${MARKET_HISTORY_CACHE_VERSION}`
-  }
-
-  #setCache = async ({ currency, granularity, pricesByAssetName }) => {
-    const assets = this.assetsModule.getAssets()
-
-    const promises = Object.values(assets).map((asset) => {
-      const key = this.#getCacheKey({ currency, assetName: asset.name, granularity })
-      const values = pricesByAssetName[asset.name]
-      return this.storage.set(key, values)
-    })
-
-    await Promise.all(promises)
-  }
-
-  #getCache = async ({ currency, granularity, assetName }) => {
-    const key = this.#getCacheKey({ currency, assetName, granularity })
-    const cache = await this.storage.get(key)
-    return cache || []
-  }
-
-  #fetch = async ({ currency, granularity }) => {
-    const assets = this.assetsModule.getAssets()
-    const assetTickers = getAssetTickers(assets)
-
-    const pricesMap = await fetchHistoricalPrices({
-      api: (...args) => this.#pricingServer.historicalPrice(...args),
-      assetTickers,
-      fiatTicker: currency,
-      granularity,
-      ignoreInvalidSymbols: true,
-      getCurrentTime: SynchronizedTime.now,
-      getCacheFromStorage: async (ticker) =>
-        this.#getCache({
-          currency,
-          granularity,
-          assetName: getAssetFromTicker(assets, ticker)?.name,
-        }),
-    })
-
-    const pricesByAssetName = mapValues(assets, (asset) => {
-      const assetPricesMap = pricesMap.get(asset.ticker)
-      return assetPricesMap ? [...assetPricesMap] : []
-    })
-
-    this.#setCache({ currency, granularity, pricesByAssetName })
-
-    return transformPricesByAssetName(pricesByAssetName)
-  }
-
-  #getCurrency = async () => {
-    return this.#currencyAtom.get()
-  }
-
-  #update = async (granularity) => {
-    const parsedGranularity = parseGranularity(granularity)
-    const currency = await this.#getCurrency()
-
-    try {
-      const prices = await this.#fetch({ currency, granularity })
-      this.emit('market-history', { currency, granularity: parsedGranularity, prices })
-    } catch (error) {
-      console.error(
-        'MarketHistoryMonitor: Failed to fetch rates',
-        currency,
-        parsedGranularity,
-        error
-      )
-    }
-  }
-
-  #syncGranularity = async (granularity) => {
-    const parsedGranularity = parseGranularity(granularity)
-    const currency = await this.#getCurrency()
-    const assets = this.assetsModule.getAssets()
-
-    const keys = Object.keys(assets).map((assetName) =>
-      this.#getCacheKey({ currency, assetName, granularity })
-    )
-    const cachedPrices = await this.storage.batchGet(keys)
-
-    const cachedPricesByAssetName = Object.fromEntries(
-      Object.keys(assets).map((assetName, index) => [assetName, cachedPrices[index]])
-    )
-
-    const prices = transformPricesByAssetName(cachedPricesByAssetName)
-    this.emit('market-history', { currency, granularity: parsedGranularity, prices })
-  }
-
-  sync = async () => {
-    this.#syncGranularity('day')
-    this.#syncGranularity('hour')
-  }
-
-  start = async () => {
-    if (this.#started) return
-
-    this.#started = true
-
-    const jitter = ms('3s')
-    const getCurrentTime = SynchronizedTime.now
-    const updateDayPrices = this.#update.bind(this, 'day')
-    const updateHourPrices = this.#update.bind(this, 'hour')
-
-    fetchPricesInterval({
-      func: updateDayPrices,
-      granularity: 'day',
-      jitter,
-      getCurrentTime,
-    })
-
-    fetchPricesInterval({
-      func: updateHourPrices,
-      granularity: 'hour',
-      jitter,
-      getCurrentTime,
-    })
-  }
-}
-
-const createMarketHistoryMonitor = (args = {}) => new MarketHistoryMonitor({ ...args })
-
-export default createMarketHistoryMonitor