@exodus/market-history 10.6.2 → 10.7.0

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [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
+
+- fix(market-history): crop minute history to prevent unbounded growth (#15898)
+
 ## [10.6.2](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/market-history@10.6.1...@exodus/market-history@10.6.2) (2026-04-07)
 
 ### Bug Fixes

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,6 +103,7 @@ declare const marketHistory: ({ clearHistoryCacheDefaultValue, remoteConfigClear
                 marketHistoryMonitor: {
                     start: () => Promise<void>;
                     stop: () => void;
+                    hydrate: () => Promise<void>;
                 };
                 marketHistoryAtom: import("@exodus/atoms").Atom<import("./types.js").MarketHistoryState>;
                 appProcessAtom?: import("@exodus/atoms").ReadonlyAtom<{
@@ -111,8 +112,8 @@ declare const marketHistory: ({ clearHistoryCacheDefaultValue, remoteConfigClear
                 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"];

package/lib/module/crop-history.d.ts

@@ -1,6 +1,8 @@
 import type { PriceData } from '../types.js';
-declare const cropHistory: ({ history, hourlyLimit, }: {
+type CropStep = 'hour' | 'minute';
+declare const cropHistory: ({ history, limit, step, }: {
     history: Map<number, PriceData>;
-    hourlyLimit: number;
+    limit: number;
+    step: CropStep;
 }) => Map<number, PriceData>;
 export default cropHistory;

package/lib/module/crop-history.js

@@ -1,11 +1,15 @@
 import ms from 'ms';
 import lastTimestampFromPricesMap from './last-timestamp-from-prices-map.js';
-const hourMs = ms('1h');
-const cropHistory = ({ history, hourlyLimit, }) => {
+const STEP_MS = {
+    hour: ms('1h'),
+    minute: ms('1m'),
+};
+const cropHistory = ({ history, limit, step, }) => {
+    const stepMs = STEP_MS[step];
     const lastCachedTime = lastTimestampFromPricesMap(history);
     if (!lastCachedTime)
         return history;
-    const limitedTime = lastCachedTime - hourMs * hourlyLimit;
+    const limitedTime = lastCachedTime - stepMs * limit;
     const result = new Map();
     for (const [key, value] of history.entries()) {
         if (key > limitedTime) {

package/lib/module/index.js

@@ -139,21 +139,38 @@ class MarketHistoryMonitorImpl {
     }
     #isActive = false;
     #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);
@@ -396,7 +413,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,12 +459,72 @@ 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.#isActive) {
+            return;
+        }
         const remoteConfigClearCacheVersion = await this.#remoteConfigClearCacheAtom.get();
         await this.#invalidateStorage({ remoteConfigClearCacheVersion });
         if (!this.#isActive) {

package/lib/module/process-api-response.js

@@ -28,8 +28,11 @@ export default function processApiResponse({ assetTicker, fiatTicker, fetchedPri
             added++;
         }
     }
-    if (granularity === 'hour' && !specificTimestamp && added > 0 && requestLimit) {
-        history = cropHistory({ history, hourlyLimit: requestLimit });
+    if ((granularity === 'hour' || granularity === 'minute') &&
+        !specificTimestamp &&
+        added > 0 &&
+        requestLimit) {
+        history = cropHistory({ history, limit: requestLimit, step: granularity });
     }
     return history;
 }

package/lib/plugin/index.d.ts

@@ -3,6 +3,7 @@ import type { ErrorTracking, MarketHistoryPort, MarketHistoryState } from '../ty
 type MarketHistoryMonitor = {
     start: () => Promise<void>;
     stop: () => void;
+    hydrate: () => Promise<void>;
 };
 type Dependencies = {
     marketHistoryMonitor: MarketHistoryMonitor;
@@ -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 = {
@@ -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.2",
+  "version": "10.7.0",
   "description": "Fetches historical prices for assets",
   "author": "Exodus Movement, Inc.",
   "license": "MIT",
@@ -23,8 +23,8 @@
     "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 +36,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.4.0",
     "@exodus/storage-memory": "^2.4.0",
     "events": "^3.3.0",
     "redux": "^4.0.0"
@@ -61,5 +61,5 @@
     "access": "public",
     "provenance": false
   },
-  "gitHead": "81d696384e63a90493e3e4b563ef60727f1b0db4"
+  "gitHead": "15750a8f551c1d4d869c6a133f1c5199c6dcfa93"
 }