@exodus/market-history 10.6.3 → 10.7.1

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [10.7.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/market-history@10.7.0...@exodus/market-history@10.7.1) (2026-05-04)
+
+**Note:** Version bump only for package @exodus/market-history
+
+## [10.7.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/market-history@10.6.3...@exodus/market-history@10.7.0) (2026-05-01)
+
+### Features
+
+- feat(market-history): hydrate prices from cache on start (#16273)
+
 ## [10.6.3](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/market-history@10.6.2...@exodus/market-history@10.6.3) (2026-04-08)
 
 ### Bug Fixes

package/lib/atoms/index.d.ts

@@ -3,7 +3,7 @@ import type { MarketHistoryState } from '../types.js';
 export declare const marketHistoryAtomDefinition: {
     readonly id: "marketHistoryAtom";
     readonly type: "atom";
-    readonly factory: () => import("@exodus/atoms").Atom<MarketHistoryState>;
+    readonly factory: () => import("@exodus/atoms").Atom<MarketHistoryState | undefined>;
     readonly dependencies: readonly [];
     readonly public: true;
 };

package/lib/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_DAILY_REQUEST_LIMIT = 366;
+export declare const DEFAULT_HOURLY_REQUEST_LIMIT: number;
+export declare const DEFAULT_MINUTELY_REQUEST_LIMIT: number;

package/lib/constants.js

@@ -0,0 +1,3 @@
+export const DEFAULT_DAILY_REQUEST_LIMIT = 366;
+export const DEFAULT_HOURLY_REQUEST_LIMIT = 7 * 24;
+export const DEFAULT_MINUTELY_REQUEST_LIMIT = 2 * 60;

package/lib/index.d.ts

@@ -62,7 +62,7 @@ declare const marketHistory: ({ clearHistoryCacheDefaultValue, remoteConfigClear
                     path: string;
                     defaultValue: string | null;
                 };
-                remoteConfig: import("features/remote-config/lib/index.js").RemoteConfigType;
+                remoteConfig: import("@exodus/remote-config").RemoteConfigType;
             }) => import("@exodus/atoms").ReadonlyAtom<string | null>;
             readonly dependencies: readonly ["config", "remoteConfig"];
             readonly public: true;
@@ -83,7 +83,7 @@ declare const marketHistory: ({ clearHistoryCacheDefaultValue, remoteConfigClear
                     path: string;
                     defaultValue: number | null;
                 };
-                remoteConfig: import("features/remote-config/lib/index.js").RemoteConfigType;
+                remoteConfig: import("@exodus/remote-config").RemoteConfigType;
             }) => import("@exodus/atoms").ReadonlyAtom<number | null>;
             readonly dependencies: readonly ["config", "remoteConfig"];
             readonly public: true;
@@ -103,16 +103,17 @@ declare const marketHistory: ({ clearHistoryCacheDefaultValue, remoteConfigClear
                 marketHistoryMonitor: {
                     start: () => Promise<void>;
                     stop: () => void;
+                    hydrate: () => Promise<void>;
                 };
-                marketHistoryAtom: import("@exodus/atoms").Atom<import("./types.js").MarketHistoryState>;
+                marketHistoryAtom: import("@exodus/atoms").Atom<import("./types.js").MarketHistoryState | undefined>;
                 appProcessAtom?: import("@exodus/atoms").ReadonlyAtom<{
                     mode: string;
                 }>;
                 port: import("./types.js").MarketHistoryPort;
                 errorTracking: import("./types.js").ErrorTracking;
             }) => {
+                onStart: () => void;
                 onUnlock: () => void;
-                onLoad: () => void;
                 onStop: () => void;
             };
             readonly dependencies: readonly ["marketHistoryMonitor", "marketHistoryAtom", "appProcessAtom?", "port", "errorTracking"];
@@ -125,7 +126,7 @@ declare const marketHistory: ({ clearHistoryCacheDefaultValue, remoteConfigClear
         definition: {
             readonly id: "marketHistoryAtom";
             readonly type: "atom";
-            readonly factory: () => import("@exodus/atoms").Atom<import("./types.js").MarketHistoryState>;
+            readonly factory: () => import("@exodus/atoms").Atom<import("./types.js").MarketHistoryState | undefined>;
             readonly dependencies: readonly [];
             readonly public: true;
         };

package/lib/index.js

@@ -3,11 +3,9 @@ import { marketHistoryAtomDefinition, marketHistoryClearCacheAtomDefinition, mar
 import marketHistoryMonitorDefinition from './module/index.js';
 import marketHistoryPluginDefinition from './plugin/index.js';
 import marketHistoryApiDefinition from './api/index.js';
+import { DEFAULT_DAILY_REQUEST_LIMIT, DEFAULT_HOURLY_REQUEST_LIMIT, DEFAULT_MINUTELY_REQUEST_LIMIT, } from './constants.js';
 const CLEAR_MARKET_HISTORY_VERSION = 'infrastructure.marketHistory.clearVersion';
 const REFRESH_INTERVAL_ATOM_PATH = 'infrastructure.marketHistory.refreshInterval';
-const DEFAULT_DAILY_REQUEST_LIMIT = 366;
-const DEFAULT_HOURLY_REQUEST_LIMIT = 7 * 24;
-const DEFAULT_MINUTELY_REQUEST_LIMIT = 2 * 60;
 const marketHistory = ({ clearHistoryCacheDefaultValue = null, remoteConfigClearHistoryCachePath = CLEAR_MARKET_HISTORY_VERSION, remoteConfigClearHistoryCacheDefaultValue = null, marketHistoryRefreshIntervalPath = REFRESH_INTERVAL_ATOM_PATH, marketHistoryRefreshIntervalDefaultValue = null, dailyRequestLimit = DEFAULT_DAILY_REQUEST_LIMIT, hourlyRequestLimit = DEFAULT_HOURLY_REQUEST_LIMIT, minutelyRequestLimit = DEFAULT_MINUTELY_REQUEST_LIMIT, } = Object.create(null)) => {
     return {
         id: safeString `marketHistory`,

package/lib/module/fetch-and-process-tickers.d.ts

@@ -14,6 +14,6 @@ export default function fetchAndProcessTickers({ assetTickersToFetch, api, fiatT
     historicalPricesMap: Map<string, Map<number, PriceData>>;
     fetchedPricesMap: Map<string, Map<number, PriceData>>;
     specificTimestamp?: number | null;
-    requestLimit?: number;
+    requestLimit: number;
 }): Promise<void>;
 export {};

package/lib/module/fetch-historical-prices.d.ts

@@ -5,7 +5,7 @@ export default function fetchHistoricalPrices({ api, assetTickers, fiatTicker, g
     fiatTicker: string;
     granularity?: Granularity;
     getCacheFromStorage: (ticker: string) => Promise<CacheEntry[] | string | undefined>;
-    requestLimit?: number;
+    requestLimit: number;
     timestamp?: number;
     getCurrentTime?: () => number;
     ignoreInvalidSymbols?: boolean;

package/lib/module/get-limit-to-fetch.d.ts

@@ -3,7 +3,7 @@ declare const getLimit: ({ granularity, history, requestLimit, requestTimestamp,
     granularity: Granularity;
     history: Map<number, PriceData>;
     requestTimestamp: number;
-    requestLimit?: number;
+    requestLimit: number;
     specificTimestamp?: number | null;
 }) => number;
 export default getLimit;

package/lib/module/get-limit-to-fetch.js

@@ -1,21 +1,20 @@
-import { LIMIT, START_TIME } from './constants.js';
 import lastTimestampFromPricesMap from './last-timestamp-from-prices-map.js';
 import { timeToDays, timeToHours, timeToMinutes } from './utils.js';
+const START_TIME = new Date('2015-12-09').getTime();
 const getLimit = ({ granularity, history, requestLimit, requestTimestamp, specificTimestamp, }) => {
     if (specificTimestamp)
         return 1;
     const lastCachedTime = lastTimestampFromPricesMap(history);
-    const limitFromOptions = requestLimit || LIMIT[granularity];
     if (granularity === 'minute') {
         if (!lastCachedTime)
-            return limitFromOptions;
-        return Math.ceil(Math.min(limitFromOptions, timeToMinutes(requestTimestamp - lastCachedTime)));
+            return requestLimit;
+        return Math.ceil(Math.min(requestLimit, timeToMinutes(requestTimestamp - lastCachedTime)));
     }
     if (granularity === 'hour') {
         if (!lastCachedTime)
-            return limitFromOptions;
-        return Math.min(limitFromOptions, timeToHours(requestTimestamp - lastCachedTime));
+            return requestLimit;
+        return Math.min(requestLimit, timeToHours(requestTimestamp - lastCachedTime));
     }
-    return Math.min(limitFromOptions, timeToDays(requestTimestamp - (lastCachedTime || START_TIME)));
+    return Math.min(requestLimit, timeToDays(requestTimestamp - (lastCachedTime || START_TIME)));
 };
 export default getLimit;

package/lib/module/index.js

@@ -109,7 +109,7 @@ class MarketHistoryMonitorImpl {
     #runtimeCache = new Map();
     #marketHistoryAtom;
     #enabledAssetsAtom;
-    #granularityRequestLimits = null;
+    #granularityRequestLimits;
     #logger;
     #abortController = new AbortController();
     #synchronizedTime;
@@ -138,22 +138,42 @@ class MarketHistoryMonitorImpl {
         this.#synchronizedTime = synchronizedTime;
     }
     #isActive = false;
+    #stillActive() {
+        return this.#isActive;
+    }
     #setCache = async ({ currency, granularity, pricesByAssetName, }) => {
-        let hasChanges = false;
-        const changes = Object.keys(pricesByAssetName).reduce((acc, assetName) => {
-            const key = this.#getCacheKey({ currency, assetName, granularity });
+        const assetNamesWithChanges = [];
+        const changes = Object.create(null);
+        for (const assetName of Object.keys(pricesByAssetName)) {
             const values = pricesByAssetName[assetName];
             if (values.length > 0) {
-                hasChanges = true;
-                acc[key] = values;
+                const key = this.#getCacheKey({ currency, assetName, granularity });
+                assetNamesWithChanges.push(assetName);
+                changes[key] = values;
                 this.#runtimeCache.set(key, values);
             }
-            return acc;
-        }, Object.create(null));
-        if (!hasChanges)
+        }
+        if (assetNamesWithChanges.length === 0)
             return;
         await this.storage.batchSet(changes);
+        await this.#extendCacheIndex(currency, assetNamesWithChanges);
     };
+    #cacheIndexKey = (currency) => `cached-assets-${currency}`;
+    #extendCacheIndex = makeConcurrent(async (currency, addedAssetNames) => {
+        const indexKey = this.#cacheIndexKey(currency);
+        const existing = ((await this.storage.get(indexKey)) || []);
+        const existingSet = new Set(existing);
+        let added = 0;
+        for (const name of addedAssetNames) {
+            if (!existingSet.has(name)) {
+                existingSet.add(name);
+                added += 1;
+            }
+        }
+        if (added === 0)
+            return;
+        await this.storage.set(indexKey, [...existingSet]);
+    }, { concurrency: 1 });
     #getCache = async ({ currency, granularity, assetName, }) => {
         const key = this.#getCacheKey({ currency, assetName, granularity });
         const cachedValue = this.#runtimeCache.get(key);
@@ -169,7 +189,7 @@ class MarketHistoryMonitorImpl {
         granularity,
         assetName: getAssetFromTicker(this.assetsModule.getAssets(), assetTicker).name,
     });
-    #fetch = async ({ currency, granularity, assetNames, requestLimit, }) => {
+    #fetch = async ({ currency, granularity, assetNames, }) => {
         const assets = this.assetsModule.getAssets();
         const assetTickers = assetNames
             .filter((assetName) => !assets[assetName].isCombined)
@@ -202,7 +222,7 @@ class MarketHistoryMonitorImpl {
             ignoreCache,
             runtimeCache: this.#runtimeCache,
             getRuntimeCacheKey: ({ fiatTicker, granularity, assetTicker, }) => this.#getRuntimeCacheKey({ fiatTicker, granularity, assetTicker }),
-            requestLimit: requestLimit || this.#granularityRequestLimits[granularity],
+            requestLimit: this.#granularityRequestLimits[granularity],
         });
         if (fetchedPricesMap.size > 0) {
             const pricesByAssetNameForCache = mapPricesForCache(fetchedPricesMap, assetNames, assets);
@@ -290,7 +310,7 @@ class MarketHistoryMonitorImpl {
         const currency = this.#currency;
         const promises = granularities.map((granularity) => this.#fetchPricesByGranularity({ granularity, assetNames, currency }));
         const results = await Promise.all(promises);
-        if (!this.#isActive) {
+        if (!this.#stillActive()) {
             return;
         }
         await this.#marketHistoryAtom.set((current) => {
@@ -313,7 +333,7 @@ class MarketHistoryMonitorImpl {
                     daily: Object.create(null),
                     hourly: Object.create(null),
                     minutely: Object.create(null),
-                    ...current?.data?.[currency],
+                    ...current?.data[currency],
                 },
             };
             granularities.forEach((granularity, index) => {
@@ -396,7 +416,7 @@ class MarketHistoryMonitorImpl {
                 this.#logger.info('market history update because currency changes', currency);
                 this.#currency = currency;
                 void this.#marketHistoryAtom.set((current) => {
-                    const data = current?.data || {};
+                    const data = current?.data || Object.create(null);
                     return {
                         data: {
                             ...data,
@@ -442,31 +462,91 @@ class MarketHistoryMonitorImpl {
             };
         });
     };
+    #hydratePromise = null;
+    hydrate = () => {
+        this.#hydratePromise ??= this.#performHydrate();
+        return this.#hydratePromise;
+    };
+    #performHydrate = async () => {
+        const currency = await this.#currencyAtom.get();
+        const indexed = ((await this.storage.get(this.#cacheIndexKey(currency))) || []);
+        if (indexed.length === 0)
+            return;
+        const granularities = ['day', 'hour', 'minute'];
+        const keys = [];
+        const meta = [];
+        for (const assetName of indexed) {
+            for (const granularity of granularities) {
+                keys.push(this.#getCacheKey({ currency, assetName, granularity }));
+                meta.push({ assetName, granularity });
+            }
+        }
+        const results = (await this.storage.batchGet(keys));
+        const granularityPrices = {
+            daily: Object.create(null),
+            hourly: Object.create(null),
+            minutely: Object.create(null),
+        };
+        let hydratedCount = 0;
+        results.forEach((cacheEntries, index) => {
+            if (!cacheEntries || cacheEntries.length === 0)
+                return;
+            const { assetName, granularity } = meta[index];
+            const key = keys[index];
+            this.#runtimeCache.set(key, cacheEntries);
+            const priceRecord = new Map();
+            for (const [time, { close }] of cacheEntries) {
+                priceRecord.set(time, close);
+            }
+            const parsedGranularity = parseGranularity(granularity);
+            granularityPrices[parsedGranularity][assetName] = priceRecord;
+            hydratedCount += 1;
+        });
+        if (hydratedCount === 0)
+            return;
+        await this.#marketHistoryAtom.set((current) => {
+            if (current?.data[currency])
+                return current;
+            return {
+                data: {
+                    ...current?.data,
+                    [currency]: granularityPrices,
+                },
+            };
+        });
+        this.#logger.info(`market history hydrated from cache (currency=${currency})`);
+    };
     start = makeConcurrent(async () => {
         if (this.#isActive)
             return;
         this.#logger.info('market history start');
         this.#isActive = true;
         this.#abortController = new AbortController();
+        await this.hydrate().catch((error) => {
+            this.#logger.error('market history hydrate failed', error);
+        });
+        if (!this.#stillActive()) {
+            return;
+        }
         const remoteConfigClearCacheVersion = await this.#remoteConfigClearCacheAtom.get();
         await this.#invalidateStorage({ remoteConfigClearCacheVersion });
-        if (!this.#isActive) {
+        if (!this.#stillActive()) {
             return;
         }
         this.#currency = await this.#currencyAtom.get();
         this.#previouslyEnabledAssets = await this.#enabledAssetsAtom.get();
-        if (!this.#isActive) {
+        if (!this.#stillActive()) {
             return;
         }
         await this.#initMarketHistoryAtom();
-        if (!this.#isActive) {
+        if (!this.#stillActive()) {
             return;
         }
         this.#setupTimers();
         this.#listenRemoteConfigClearCacheVersionChanges();
         this.#listenCurrencyChanges();
         this.#listenEnabledAssetsChanges();
-        if (!this.#isActive) {
+        if (!this.#stillActive()) {
             return;
         }
         await this.updateAll();
@@ -539,9 +619,9 @@ class MarketHistoryMonitorImpl {
             return {
                 data: {
                     [currency]: {
-                        ...current?.data?.[currency],
+                        ...current?.data[currency],
                         [parsedGranularity]: {
-                            ...current?.data?.[currency]?.[parsedGranularity],
+                            ...current?.data[currency]?.[parsedGranularity],
                             [assetName]: transformedPrices,
                         },
                     },

package/lib/module/prepare-fetch-instructions.d.ts

@@ -4,7 +4,7 @@ export default function prepareFetchInstructions({ tickerSymbol, fiatTicker, gra
     fiatTicker: string;
     granularity: Granularity;
     getCacheFromStorage: (ticker: string) => Promise<CacheEntry[] | string | undefined>;
-    requestLimit?: number;
+    requestLimit: number;
     specificTimestamp?: number | null;
     ignoreCache: boolean;
     runtimeCache: Map<string, CacheEntry[]>;

package/lib/module/process-api-response.d.ts

@@ -8,5 +8,5 @@ export default function processApiResponse({ assetTicker, fiatTicker, fetchedPri
     historicalPricesMap: Map<string, Map<number, PriceData>>;
     granularity: Granularity;
     specificTimestamp?: number | null;
-    requestLimit?: number;
+    requestLimit: number;
 }): Map<number, PriceData> | null;

package/lib/plugin/index.d.ts

@@ -3,10 +3,11 @@ import type { ErrorTracking, MarketHistoryPort, MarketHistoryState } from '../ty
 type MarketHistoryMonitor = {
     start: () => Promise<void>;
     stop: () => void;
+    hydrate: () => Promise<void>;
 };
 type Dependencies = {
     marketHistoryMonitor: MarketHistoryMonitor;
-    marketHistoryAtom: Atom<MarketHistoryState>;
+    marketHistoryAtom: Atom<MarketHistoryState | undefined>;
     appProcessAtom?: ReadonlyAtom<{
         mode: string;
     }>;
@@ -17,8 +18,8 @@ declare const marketHistoryLifecyclePluginDefinition: {
     readonly id: "marketHistoryLifecyclePlugin";
     readonly type: "plugin";
     readonly factory: ({ marketHistoryMonitor, marketHistoryAtom, appProcessAtom, port, errorTracking, }: Dependencies) => {
+        onStart: () => void;
         onUnlock: () => void;
-        onLoad: () => void;
         onStop: () => void;
     };
     readonly dependencies: readonly ["marketHistoryMonitor", "marketHistoryAtom", "appProcessAtom?", "port", "errorTracking"];

package/lib/plugin/index.js

@@ -19,8 +19,11 @@ const createMarketHistoryLifecyclePlugin = ({ marketHistoryMonitor, marketHistor
             previousMode = mode;
         });
     };
-    const onLoad = () => {
+    const onStart = () => {
         void observer.start();
+        marketHistoryMonitor.hydrate().catch((e) => {
+            errorTracking.track({ error: e, context: 'start' });
+        });
     };
     const onUnlock = () => {
         const nonBlockingStart = async () => {
@@ -40,7 +43,7 @@ const createMarketHistoryLifecyclePlugin = ({ marketHistoryMonitor, marketHistor
         unobserve?.();
         marketHistoryMonitor.stop();
     };
-    return { onUnlock, onLoad, onStop };
+    return { onStart, onUnlock, onStop };
 };
 const marketHistoryLifecyclePluginDefinition = {
     id: 'marketHistoryLifecyclePlugin',

package/lib/types.d.ts

@@ -56,6 +56,7 @@ export type MarketHistoryStorage = {
     get: (key: string) => Promise<unknown>;
     set: (key: string, value: unknown) => Promise<void>;
     clear: () => Promise<void>;
+    batchGet: (keys: string[]) => Promise<unknown[]>;
     batchSet: (changes: Record<string, CacheEntry[]>) => Promise<void>;
 };
 export type AssetsModule = {
@@ -76,7 +77,7 @@ export type MarketHistoryMonitorDependencies = {
     clearCacheAtom?: Atom<string | null>;
     remoteConfigClearCacheAtom?: Atom<string | null>;
     enabledAssetsAtom: ReadonlyAtom<Record<string, Asset>>;
-    marketHistoryAtom: Atom<MarketHistoryState>;
+    marketHistoryAtom: Atom<MarketHistoryState | undefined>;
     logger: Logger;
     config?: {
         granularityRequestLimits?: Record<Granularity, number>;
@@ -89,6 +90,7 @@ export type MarketHistoryMonitorDependencies = {
 export type MarketHistoryMonitor = {
     start: () => Promise<void>;
     stop: () => void;
+    hydrate: () => Promise<void>;
     update: (granularity: Granularity) => Promise<void>;
     updateAll: () => Promise<void>;
     fetchAssetPricesFromDate: (params: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/market-history",
-  "version": "10.6.3",
+  "version": "10.7.1",
   "description": "Fetches historical prices for assets",
   "author": "Exodus Movement, Inc.",
   "license": "MIT",
@@ -17,14 +17,19 @@
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "typings": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js",
+    "./redux": "./lib/redux/index.js"
+  },
   "files": [
     "lib",
+    "redux.js",
     "CHANGELOG.md",
     "README.md"
   ],
   "dependencies": {
-    "@exodus/atoms": "^9.0.0",
-    "@exodus/basic-utils": "^3.7.3",
+    "@exodus/atoms": "^10.3.3",
+    "@exodus/basic-utils": "^5.0.0",
     "@exodus/dayjs": "^1.0.2",
     "@exodus/remote-config": "^3.5.1",
     "@exodus/remote-config-atoms": "^1.1.0",
@@ -36,15 +41,15 @@
   },
   "devDependencies": {
     "@exodus/assets": "^11.0.0",
-    "@exodus/assets-base": "^10.0.0",
-    "@exodus/assets-feature": "^9.0.1",
+    "@exodus/assets-base": "^12.0.0",
+    "@exodus/assets-feature": "^9.2.2",
     "@exodus/bitcoin-meta": "^2.0.0",
     "@exodus/dependency-types": "^2.1.1",
     "@exodus/ethereum-meta": "^2.4.1",
-    "@exodus/locale": "^2.6.0",
+    "@exodus/locale": "^2.7.0",
     "@exodus/logger": "^1.2.3",
     "@exodus/rates-monitor": "^4.14.8",
-    "@exodus/redux-dependency-injection": "^4.1.2",
+    "@exodus/redux-dependency-injection": "^4.5.0",
     "@exodus/storage-memory": "^2.4.0",
     "events": "^3.3.0",
     "redux": "^4.0.0"
@@ -61,5 +66,5 @@
     "access": "public",
     "provenance": false
   },
-  "gitHead": "2c948759e38769a0d3a02916fd8b571e0c96e494"
+  "gitHead": "ef035f3c387767ab37076ad2d2dfb8be62f19ea6"
 }

package/redux.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/no-unresolved -- shim re-exports built artifact
+export { default } from './lib/redux/index.js'

package/lib/module/constants.d.ts

@@ -1,2 +0,0 @@
-export declare const LIMIT: Record<string, number>;
-export declare const START_TIME: number;

package/lib/module/constants.js

@@ -1,9 +0,0 @@
-const HOURLY_LIMIT = 24 * 7;
-const DAILY_LIMIT = 3000;
-const MINUTE_LIMIT = 60 * 2;
-export const LIMIT = {
-    minute: MINUTE_LIMIT,
-    hour: HOURLY_LIMIT,
-    day: DAILY_LIMIT,
-};
-export const START_TIME = new Date('2015-12-09').getTime();