@exodus/market-history 10.6.1 → 10.6.2

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [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
+
+- fix(market-history): use Map for PriceRecord to avoid Hermes property limit crash (#15897)
+
 ## [10.6.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/market-history@10.6.0...@exodus/market-history@10.6.1) (2026-02-24)
 
 ### Performance

package/lib/api/index.d.ts

@@ -0,0 +1,20 @@
+import type { MarketHistoryMonitor } from '../types.js';
+declare const marketHistoryApiDefinition: {
+    readonly id: "marketHistoryApi";
+    readonly type: "api";
+    readonly factory: ({ marketHistoryMonitor, }: {
+        marketHistoryMonitor: MarketHistoryMonitor;
+    }) => {
+        marketHistory: {
+            update: (granularity: import("../types.js").Granularity) => Promise<void>;
+            updateAll: () => Promise<void>;
+            fetchAssetPricesFromDate: (params: {
+                assetName: string;
+                granularity: import("../types.js").Granularity;
+                startTimestamp: number;
+            }) => Promise<void>;
+        };
+    };
+    readonly dependencies: readonly ["marketHistoryMonitor"];
+};
+export default marketHistoryApiDefinition;

package/lib/api/index.js

@@ -0,0 +1,16 @@
+const createMarketHistoryApi = ({ marketHistoryMonitor, }) => {
+    return {
+        marketHistory: {
+            update: marketHistoryMonitor.update,
+            updateAll: marketHistoryMonitor.updateAll,
+            fetchAssetPricesFromDate: marketHistoryMonitor.fetchAssetPricesFromDate,
+        },
+    };
+};
+const marketHistoryApiDefinition = {
+    id: 'marketHistoryApi',
+    type: 'api',
+    factory: createMarketHistoryApi,
+    dependencies: ['marketHistoryMonitor'],
+};
+export default marketHistoryApiDefinition;

package/lib/atoms/index.d.ts

@@ -0,0 +1,46 @@
+import type { RemoteConfigType } from '@exodus/remote-config';
+import type { MarketHistoryState } from '../types.js';
+export declare const marketHistoryAtomDefinition: {
+    readonly id: "marketHistoryAtom";
+    readonly type: "atom";
+    readonly factory: () => import("@exodus/atoms").Atom<MarketHistoryState>;
+    readonly dependencies: readonly [];
+    readonly public: true;
+};
+export declare const marketHistoryRefreshIntervalAtomDefinition: {
+    readonly id: "marketHistoryRefreshIntervalAtom";
+    readonly type: "atom";
+    readonly factory: ({ config, remoteConfig, }: {
+        config: {
+            path: string;
+            defaultValue: number | null;
+        };
+        remoteConfig: RemoteConfigType;
+    }) => import("@exodus/atoms").ReadonlyAtom<number | null>;
+    readonly dependencies: readonly ["config", "remoteConfig"];
+    readonly public: true;
+};
+export declare const marketHistoryClearCacheAtomDefinition: {
+    readonly id: "marketHistoryClearCacheAtom";
+    readonly type: "atom";
+    readonly factory: ({ config }: {
+        config: {
+            defaultValue: string | null;
+        };
+    }) => import("@exodus/atoms").Atom<string | null>;
+    readonly dependencies: readonly ["config"];
+    readonly public: true;
+};
+export declare const remoteConfigClearMarketHistoryCacheAtomDefinition: {
+    readonly id: "remoteConfigClearMarketHistoryCacheAtom";
+    readonly type: "atom";
+    readonly factory: ({ config, remoteConfig, }: {
+        config: {
+            path: string;
+            defaultValue: string | null;
+        };
+        remoteConfig: RemoteConfigType;
+    }) => import("@exodus/atoms").ReadonlyAtom<string | null>;
+    readonly dependencies: readonly ["config", "remoteConfig"];
+    readonly public: true;
+};

package/lib/atoms/index.js

@@ -0,0 +1,30 @@
+import { createInMemoryAtom } from '@exodus/atoms';
+import { createRemoteConfigAtomFactory } from '@exodus/remote-config-atoms';
+export const marketHistoryAtomDefinition = {
+    id: 'marketHistoryAtom',
+    type: 'atom',
+    factory: () => createInMemoryAtom(),
+    dependencies: [],
+    public: true,
+};
+export const marketHistoryRefreshIntervalAtomDefinition = {
+    id: 'marketHistoryRefreshIntervalAtom',
+    type: 'atom',
+    factory: ({ config, remoteConfig, }) => createRemoteConfigAtomFactory({ remoteConfig })(config),
+    dependencies: ['config', 'remoteConfig'],
+    public: true,
+};
+export const marketHistoryClearCacheAtomDefinition = {
+    id: 'marketHistoryClearCacheAtom',
+    type: 'atom',
+    factory: ({ config }) => createInMemoryAtom(config),
+    dependencies: ['config'],
+    public: true,
+};
+export const remoteConfigClearMarketHistoryCacheAtomDefinition = {
+    id: 'remoteConfigClearMarketHistoryCacheAtom',
+    type: 'atom',
+    factory: ({ config, remoteConfig, }) => createRemoteConfigAtomFactory({ remoteConfig })(config),
+    dependencies: ['config', 'remoteConfig'],
+    public: true,
+};

package/lib/index.d.ts

@@ -0,0 +1,159 @@
+type MarketHistoryConfig = {
+    clearHistoryCacheDefaultValue?: string | null;
+    remoteConfigClearHistoryCachePath?: string;
+    remoteConfigClearHistoryCacheDefaultValue?: string | null;
+    marketHistoryRefreshIntervalPath?: string;
+    marketHistoryRefreshIntervalDefaultValue?: number | null;
+    dailyRequestLimit?: number;
+    hourlyRequestLimit?: number;
+    minutelyRequestLimit?: number;
+};
+declare const marketHistory: ({ clearHistoryCacheDefaultValue, remoteConfigClearHistoryCachePath, remoteConfigClearHistoryCacheDefaultValue, marketHistoryRefreshIntervalPath, marketHistoryRefreshIntervalDefaultValue, dailyRequestLimit, hourlyRequestLimit, minutelyRequestLimit, }?: MarketHistoryConfig) => {
+    id: import("@exodus/safe-string").SafeString;
+    definitions: ({
+        definition: {
+            type: "monitor";
+            id: "marketHistoryMonitor";
+            factory: (args: import("./types.js").MarketHistoryMonitorDependencies) => import("./types.js").MarketHistoryMonitor;
+            dependencies: readonly ["pricingClient", "currencyAtom", "storage", "assetsModule", "clearCacheAtom", "remoteConfigClearCacheAtom", "remoteConfigRefreshIntervalAtom", "enabledAssetsAtom", "marketHistoryAtom", "logger", "getCacheKey?", "config", "synchronizedTime", "errorTracking"];
+            public: true;
+        };
+        storage: {
+            namespace: string;
+        };
+        aliases: {
+            implementationId: string;
+            interfaceId: string;
+        }[];
+        config: {
+            granularityRequestLimits: {
+                day: number;
+                hour: number;
+                minute: number;
+            };
+            defaultValue?: undefined;
+            path?: undefined;
+        };
+    } | {
+        definition: {
+            readonly id: "marketHistoryClearCacheAtom";
+            readonly type: "atom";
+            readonly factory: ({ config }: {
+                config: {
+                    defaultValue: string | null;
+                };
+            }) => import("@exodus/atoms").Atom<string | null>;
+            readonly dependencies: readonly ["config"];
+            readonly public: true;
+        };
+        config: {
+            defaultValue: string | null;
+            granularityRequestLimits?: undefined;
+            path?: undefined;
+        };
+        storage?: undefined;
+        aliases?: undefined;
+    } | {
+        definition: {
+            readonly id: "remoteConfigClearMarketHistoryCacheAtom";
+            readonly type: "atom";
+            readonly factory: ({ config, remoteConfig, }: {
+                config: {
+                    path: string;
+                    defaultValue: string | null;
+                };
+                remoteConfig: import("features/remote-config/lib/index.js").RemoteConfigType;
+            }) => import("@exodus/atoms").ReadonlyAtom<string | null>;
+            readonly dependencies: readonly ["config", "remoteConfig"];
+            readonly public: true;
+        };
+        config: {
+            path: string;
+            defaultValue: string | null;
+            granularityRequestLimits?: undefined;
+        };
+        storage?: undefined;
+        aliases?: undefined;
+    } | {
+        definition: {
+            readonly id: "marketHistoryRefreshIntervalAtom";
+            readonly type: "atom";
+            readonly factory: ({ config, remoteConfig, }: {
+                config: {
+                    path: string;
+                    defaultValue: number | null;
+                };
+                remoteConfig: import("features/remote-config/lib/index.js").RemoteConfigType;
+            }) => import("@exodus/atoms").ReadonlyAtom<number | null>;
+            readonly dependencies: readonly ["config", "remoteConfig"];
+            readonly public: true;
+        };
+        config: {
+            path: string;
+            defaultValue: number | null;
+            granularityRequestLimits?: undefined;
+        };
+        storage?: undefined;
+        aliases?: undefined;
+    } | {
+        definition: {
+            readonly id: "marketHistoryLifecyclePlugin";
+            readonly type: "plugin";
+            readonly factory: ({ marketHistoryMonitor, marketHistoryAtom, appProcessAtom, port, errorTracking, }: {
+                marketHistoryMonitor: {
+                    start: () => Promise<void>;
+                    stop: () => void;
+                };
+                marketHistoryAtom: import("@exodus/atoms").Atom<import("./types.js").MarketHistoryState>;
+                appProcessAtom?: import("@exodus/atoms").ReadonlyAtom<{
+                    mode: string;
+                }>;
+                port: import("./types.js").MarketHistoryPort;
+                errorTracking: import("./types.js").ErrorTracking;
+            }) => {
+                onUnlock: () => void;
+                onLoad: () => void;
+                onStop: () => void;
+            };
+            readonly dependencies: readonly ["marketHistoryMonitor", "marketHistoryAtom", "appProcessAtom?", "port", "errorTracking"];
+            readonly public: true;
+        };
+        storage?: undefined;
+        aliases?: undefined;
+        config?: undefined;
+    } | {
+        definition: {
+            readonly id: "marketHistoryAtom";
+            readonly type: "atom";
+            readonly factory: () => import("@exodus/atoms").Atom<import("./types.js").MarketHistoryState>;
+            readonly dependencies: readonly [];
+            readonly public: true;
+        };
+        storage?: undefined;
+        aliases?: undefined;
+        config?: undefined;
+    } | {
+        definition: {
+            readonly id: "marketHistoryApi";
+            readonly type: "api";
+            readonly factory: ({ marketHistoryMonitor, }: {
+                marketHistoryMonitor: import("./types.js").MarketHistoryMonitor;
+            }) => {
+                marketHistory: {
+                    update: (granularity: import("./types.js").Granularity) => Promise<void>;
+                    updateAll: () => Promise<void>;
+                    fetchAssetPricesFromDate: (params: {
+                        assetName: string;
+                        granularity: import("./types.js").Granularity;
+                        startTimestamp: number;
+                    }) => Promise<void>;
+                };
+            };
+            readonly dependencies: readonly ["marketHistoryMonitor"];
+        };
+        storage?: undefined;
+        aliases?: undefined;
+        config?: undefined;
+    })[];
+};
+export default marketHistory;

package/lib/index.js

@@ -0,0 +1,70 @@
+import { safeString } from '@exodus/safe-string';
+import { marketHistoryAtomDefinition, marketHistoryClearCacheAtomDefinition, marketHistoryRefreshIntervalAtomDefinition, remoteConfigClearMarketHistoryCacheAtomDefinition, } from './atoms/index.js';
+import marketHistoryMonitorDefinition from './module/index.js';
+import marketHistoryPluginDefinition from './plugin/index.js';
+import marketHistoryApiDefinition from './api/index.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`,
+        definitions: [
+            {
+                definition: { ...marketHistoryMonitorDefinition, type: 'monitor' },
+                storage: { namespace: 'marketHistory' },
+                aliases: [
+                    {
+                        implementationId: 'unsafeStorage',
+                        interfaceId: 'storage',
+                    },
+                    {
+                        implementationId: 'marketHistoryClearCacheAtom',
+                        interfaceId: 'clearCacheAtom',
+                    },
+                    {
+                        implementationId: 'remoteConfigClearMarketHistoryCacheAtom',
+                        interfaceId: 'remoteConfigClearCacheAtom',
+                    },
+                    {
+                        implementationId: 'marketHistoryRefreshIntervalAtom',
+                        interfaceId: 'remoteConfigRefreshIntervalAtom',
+                    },
+                ],
+                config: {
+                    granularityRequestLimits: {
+                        day: dailyRequestLimit,
+                        hour: hourlyRequestLimit,
+                        minute: minutelyRequestLimit,
+                    },
+                },
+            },
+            {
+                definition: marketHistoryClearCacheAtomDefinition,
+                config: {
+                    defaultValue: clearHistoryCacheDefaultValue,
+                },
+            },
+            {
+                definition: remoteConfigClearMarketHistoryCacheAtomDefinition,
+                config: {
+                    path: remoteConfigClearHistoryCachePath,
+                    defaultValue: remoteConfigClearHistoryCacheDefaultValue,
+                },
+            },
+            {
+                definition: marketHistoryRefreshIntervalAtomDefinition,
+                config: {
+                    path: marketHistoryRefreshIntervalPath,
+                    defaultValue: marketHistoryRefreshIntervalDefaultValue,
+                },
+            },
+            { definition: marketHistoryPluginDefinition },
+            { definition: marketHistoryAtomDefinition },
+            { definition: marketHistoryApiDefinition },
+        ],
+    };
+};
+export default marketHistory;

package/lib/module/constants.d.ts

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

package/lib/module/constants.js

@@ -0,0 +1,9 @@
+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();

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

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

package/lib/module/crop-history.js

@@ -0,0 +1,17 @@
+import ms from 'ms';
+import lastTimestampFromPricesMap from './last-timestamp-from-prices-map.js';
+const hourMs = ms('1h');
+const cropHistory = ({ history, hourlyLimit, }) => {
+    const lastCachedTime = lastTimestampFromPricesMap(history);
+    if (!lastCachedTime)
+        return history;
+    const limitedTime = lastCachedTime - hourMs * hourlyLimit;
+    const result = new Map();
+    for (const [key, value] of history.entries()) {
+        if (key > limitedTime) {
+            result.set(key, value);
+        }
+    }
+    return result;
+};
+export default cropHistory;

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

@@ -0,0 +1,19 @@
+import type { FetchApiFunction, Granularity, PriceData } from '../types.js';
+type TickerToFetch = {
+    tickerSymbol: string;
+    limit: number;
+    lastCachedItem?: PriceData;
+};
+export default function fetchAndProcessTickers({ assetTickersToFetch, api, fiatTicker, granularity, timestamp, ignoreInvalidSymbols, historicalPricesMap, fetchedPricesMap, specificTimestamp, requestLimit, }: {
+    assetTickersToFetch: TickerToFetch[];
+    api: FetchApiFunction;
+    fiatTicker: string;
+    granularity: Granularity;
+    timestamp?: number;
+    ignoreInvalidSymbols: boolean;
+    historicalPricesMap: Map<string, Map<number, PriceData>>;
+    fetchedPricesMap: Map<string, Map<number, PriceData>>;
+    specificTimestamp?: number | null;
+    requestLimit?: number;
+}): Promise<void>;
+export {};

package/lib/module/fetch-and-process-tickers.js

@@ -0,0 +1,46 @@
+import processApiResponse from './process-api-response.js';
+export default async function fetchAndProcessTickers({ assetTickersToFetch, api, fiatTicker, granularity, timestamp, ignoreInvalidSymbols, historicalPricesMap, fetchedPricesMap, specificTimestamp, requestLimit, }) {
+    if (assetTickersToFetch.length === 0) {
+        return;
+    }
+    const lastCachedItemByTicker = new Map();
+    for (const { tickerSymbol, lastCachedItem } of assetTickersToFetch) {
+        lastCachedItemByTicker.set(tickerSymbol, lastCachedItem);
+    }
+    const maxLimit = Math.max(...assetTickersToFetch.map(({ limit }) => limit));
+    const requests = [
+        assetTickersToFetch.filter(({ limit }) => limit !== maxLimit),
+        assetTickersToFetch.filter(({ limit }) => limit === maxLimit),
+    ];
+    await Promise.all(requests
+        .filter((tickers) => tickers.length > 0)
+        .map(async (currentTickersToFetch) => {
+        const limit = Math.max(...currentTickersToFetch.map(({ limit }) => limit));
+        const requestParams = {
+            assets: currentTickersToFetch.map((item) => item.tickerSymbol),
+            fiatArray: [fiatTicker],
+            granularity,
+            limit,
+            timestamp,
+            ignoreInvalidSymbols,
+        };
+        const fetchedPrices = await api(requestParams);
+        Object.keys(fetchedPrices).forEach((assetTicker) => {
+            const newHistory = processApiResponse({
+                assetTicker,
+                fiatTicker,
+                fetchedPrices,
+                lastCachedItemByTicker,
+                ignoreInvalidSymbols,
+                historicalPricesMap,
+                granularity,
+                specificTimestamp,
+                requestLimit,
+            });
+            if (newHistory) {
+                fetchedPricesMap.set(assetTicker, newHistory);
+                historicalPricesMap.set(assetTicker, newHistory);
+            }
+        });
+    }));
+}

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

@@ -0,0 +1,22 @@
+import type { CacheEntry, FetchApiFunction, Granularity, PriceData } from '../types.js';
+export default function fetchHistoricalPrices({ api, assetTickers, fiatTicker, granularity, getCacheFromStorage, requestLimit, timestamp, getCurrentTime, ignoreInvalidSymbols, ignoreCache, runtimeCache, getRuntimeCacheKey, }: {
+    api: FetchApiFunction;
+    assetTickers: string | string[];
+    fiatTicker: string;
+    granularity?: Granularity;
+    getCacheFromStorage: (ticker: string) => Promise<CacheEntry[] | string | undefined>;
+    requestLimit?: number;
+    timestamp?: number;
+    getCurrentTime?: () => number;
+    ignoreInvalidSymbols?: boolean;
+    ignoreCache?: boolean;
+    runtimeCache?: Map<string, CacheEntry[]>;
+    getRuntimeCacheKey?: (params: {
+        fiatTicker: string;
+        assetTicker: string;
+        granularity: Granularity;
+    }) => string;
+}): Promise<{
+    historicalPricesMap: Map<string, Map<number, PriceData>>;
+    fetchedPricesMap: Map<string, Map<number, PriceData>>;
+}>;

package/lib/module/fetch-historical-prices.js

@@ -0,0 +1,68 @@
+import dayjs from '@exodus/dayjs';
+import { mapToArray } from '../utils.js';
+import fetchAndProcessTickers from './fetch-and-process-tickers.js';
+import prepareFetchInstructions from './prepare-fetch-instructions.js';
+const runtimeCacheDefault = new Map();
+const getRuntimeCacheKeyDefault = ({ fiatTicker, assetTicker, granularity, }) => `${assetTicker}_${fiatTicker}_${granularity}`;
+export default async function fetchHistoricalPrices({ api, assetTickers, fiatTicker, granularity = 'day', getCacheFromStorage, requestLimit, timestamp, getCurrentTime = () => Date.now(), ignoreInvalidSymbols = false, ignoreCache = false, runtimeCache = runtimeCacheDefault, getRuntimeCacheKey = getRuntimeCacheKeyDefault, }) {
+    const specificTimestamp = timestamp ? dayjs(timestamp).utc().startOf(granularity).valueOf() : null;
+    const requestTimestamp = specificTimestamp ||
+        dayjs.utc(getCurrentTime()).subtract(1, granularity).startOf(granularity).valueOf();
+    const historicalPricesMap = new Map();
+    const fetchedPricesMap = new Map();
+    const tickerSymbols = Array.isArray(assetTickers) ? assetTickers : [assetTickers];
+    if (tickerSymbols.length === 0) {
+        return {
+            historicalPricesMap,
+            fetchedPricesMap,
+        };
+    }
+    const instructions = await Promise.all(tickerSymbols.map((tickerSymbol) => prepareFetchInstructions({
+        tickerSymbol,
+        fiatTicker,
+        granularity,
+        getCacheFromStorage,
+        requestLimit,
+        specificTimestamp,
+        ignoreCache,
+        runtimeCache,
+        getRuntimeCacheKey,
+        requestTimestamp,
+    })));
+    const assetTickersToFetch = [];
+    instructions.forEach(({ history, limit, lastCachedItem, tickerSymbol }) => {
+        historicalPricesMap.set(tickerSymbol, history);
+        if (limit) {
+            assetTickersToFetch.push({ tickerSymbol, limit, lastCachedItem });
+        }
+    });
+    await fetchAndProcessTickers({
+        assetTickersToFetch,
+        api,
+        fiatTicker,
+        granularity,
+        timestamp,
+        ignoreInvalidSymbols,
+        historicalPricesMap,
+        fetchedPricesMap,
+        specificTimestamp,
+        requestLimit,
+    });
+    for (const tickerSymbol of tickerSymbols) {
+        const runtimeCacheKey = getRuntimeCacheKey({
+            fiatTicker,
+            assetTicker: tickerSymbol,
+            granularity,
+        });
+        const history = historicalPricesMap.get(tickerSymbol);
+        if (history &&
+            history.size > 0 &&
+            (fetchedPricesMap.has(tickerSymbol) || !runtimeCache.has(runtimeCacheKey))) {
+            runtimeCache.set(runtimeCacheKey, mapToArray(history));
+        }
+    }
+    return {
+        historicalPricesMap,
+        fetchedPricesMap,
+    };
+}

package/lib/module/find-invalid-price.d.ts

@@ -0,0 +1,9 @@
+type PriceItem = {
+    close: number;
+    open: number;
+    time: number;
+};
+declare const findInvalidPrice: (data: PriceItem[], lastCachedItem: {
+    close: number;
+} | undefined) => PriceItem | undefined;
+export default findInvalidPrice;

package/lib/module/find-invalid-price.js

@@ -0,0 +1,16 @@
+const isValid = (value) => value !== 0 && Number.isFinite(value);
+const findInvalidPrice = (data, lastCachedItem) => data.find((item, index) => {
+    if (!Number.isFinite(item.close) || !Number.isFinite(item.open))
+        return true;
+    if (lastCachedItem && isValid(lastCachedItem.close) && index === 0) {
+        return !isValid(item.close);
+    }
+    if (index > 0) {
+        const prevItem = data[index - 1];
+        if (!isValid(item.close) && isValid(prevItem.close))
+            return true;
+        if (!isValid(item.open) && isValid(prevItem.open))
+            return true;
+    }
+});
+export default findInvalidPrice;

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

@@ -0,0 +1,9 @@
+import type { Granularity, PriceData } from '../types.js';
+declare const getLimit: ({ granularity, history, requestLimit, requestTimestamp, specificTimestamp, }: {
+    granularity: Granularity;
+    history: Map<number, PriceData>;
+    requestTimestamp: number;
+    requestLimit?: number;
+    specificTimestamp?: number | null;
+}) => number;
+export default getLimit;

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

@@ -0,0 +1,21 @@
+import { LIMIT, START_TIME } from './constants.js';
+import lastTimestampFromPricesMap from './last-timestamp-from-prices-map.js';
+import { timeToDays, timeToHours, timeToMinutes } from './utils.js';
+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)));
+    }
+    if (granularity === 'hour') {
+        if (!lastCachedTime)
+            return limitFromOptions;
+        return Math.min(limitFromOptions, timeToHours(requestTimestamp - lastCachedTime));
+    }
+    return Math.min(limitFromOptions, timeToDays(requestTimestamp - (lastCachedTime || START_TIME)));
+};
+export default getLimit;

package/lib/module/index.d.ts

@@ -0,0 +1,9 @@
+import type { MarketHistoryMonitor, MarketHistoryMonitorDependencies } from '../types.js';
+declare const marketHistoryMonitorDefinition: {
+    readonly id: "marketHistoryMonitor";
+    readonly type: "module";
+    readonly factory: (args: MarketHistoryMonitorDependencies) => MarketHistoryMonitor;
+    readonly dependencies: readonly ["pricingClient", "currencyAtom", "storage", "assetsModule", "clearCacheAtom", "remoteConfigClearCacheAtom", "remoteConfigRefreshIntervalAtom", "enabledAssetsAtom", "marketHistoryAtom", "logger", "getCacheKey?", "config", "synchronizedTime", "errorTracking"];
+    readonly public: true;
+};
+export default marketHistoryMonitorDefinition;