@exodus/market-history 1.0.0

package/README.md

@@ -0,0 +1,39 @@
+# @exodus/market-history
+
+module fetches daily and hourly historical prices for assets by interval
+returns prices on interval `close`.
+
+## Install
+
+```sh
+yarn add @exodus/@exodus/market-history
+```
+
+## Usage
+
+```js
+import createMarketHistoryMonitor from '@exodus/market-history'
+
+const marketHistoryMonitor = createMarketHistoryMonitor({
+  assetsModule,
+  currencyAtom,
+  storage: marketHistoryStorage,
+  pricingServer,
+})
+
+marketHistoryMonitor.on('market-history', ({ currency, granularity, prices }) => {
+  // `currency` USD
+  // `granularity` daily|hourly
+  // prices
+  // {
+  //   bitcoin: {
+  //     1663668000000: 90000,
+  //     1663671600000: 120000,
+  //     1663675200000: 100000000,
+  //   }
+  // }
+})
+
+marketHistoryMonitor.start()
+marketHistoryMonitor.sync() // force to emit prices
+```

package/index.js

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

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@exodus/market-history",
+  "version": "1.0.0",
+  "description": "module to fetch historical prices for assets",
+  "author": "Exodus Movement Inc",
+  "license": "UNLICENSED",
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "yarn lint --fix",
+    "test": "jest"
+  },
+  "files": [
+    "index.js",
+    "utils.js"
+  ],
+  "dependencies": {
+    "@exodus/basic-utils": "^1.0.0",
+    "@exodus/module": "^1.0.0",
+    "@exodus/price-api": "^2.0.11",
+    "ms": "^0.7.1"
+  },
+  "devDependencies": {
+    "@exodus/assets": "^8.0.72",
+    "@exodus/atoms": "^1.0.0",
+    "@exodus/storage-memory": "^1.0.0"
+  },
+  "peerDependencies": {
+    "debug": ">= 3.0.0"
+  }
+}

package/utils.js

@@ -0,0 +1,18 @@
+export const getAssetTickers = (assets) =>
+  Object.values(assets)
+    .map((asset) => asset.ticker)
+    .sort()
+
+export const getAssetFromTicker = (assets, ticker) =>
+  Object.values(assets).find((asset) => asset.ticker === ticker)
+
+export const parseGranularity = (granularity) => {
+  switch (granularity) {
+    case 'day':
+      return 'daily'
+    case 'hour':
+      return 'hourly'
+    default:
+      return granularity
+  }
+}