lynx-client 0.0.33 → 0.0.35

package/dist/cjs/lib/marketHours/marketHoursUtils.js

@@ -0,0 +1,663 @@
+"use strict";
+/**
+ * Market hours utilities for Lynx trading pairs
+ * Data sourced from Pyth Network: https://docs.pyth.network/price-feeds/market-hours
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketTypeFromGroupId = getMarketTypeFromGroupId;
+exports.isUSInDST = isUSInDST;
+exports.getMarketStatus = getMarketStatus;
+exports.getForexMarketStatus = getForexMarketStatus;
+exports.findNextForexOpen = findNextForexOpen;
+exports.getCommoditiesMarketStatus = getCommoditiesMarketStatus;
+exports.getNextCommoditiesClose = getNextCommoditiesClose;
+exports.findNextCommoditiesOpen = findNextCommoditiesOpen;
+exports.isMarketOpen = isMarketOpen;
+exports.getMarketStatusForPair = getMarketStatusForPair;
+exports.isMarketOpenForPair = isMarketOpenForPair;
+exports.getMarketSchedule = getMarketSchedule;
+exports.getMarketScheduleForPair = getMarketScheduleForPair;
+const groupIds_1 = require("../constants/groupIds");
+const pairIds_1 = require("../constants/pairIds");
+// ============================================================================
+// NYSE Holidays (stocks market closures)
+// Source: https://www.nyse.com/markets/hours-calendars
+// ============================================================================
+const NYSE_HOLIDAYS_2025 = [
+    { date: "2025-01-01", name: "New Year's Day" },
+    { date: "2025-01-20", name: "Martin Luther King Jr. Day" },
+    { date: "2025-02-17", name: "Presidents Day" },
+    { date: "2025-04-18", name: "Good Friday" },
+    { date: "2025-05-26", name: "Memorial Day" },
+    { date: "2025-06-19", name: "Juneteenth" },
+    { date: "2025-07-04", name: "Independence Day" },
+    { date: "2025-09-01", name: "Labor Day" },
+    { date: "2025-11-27", name: "Thanksgiving" },
+    { date: "2025-12-25", name: "Christmas" },
+];
+const NYSE_HOLIDAYS_2026 = [
+    { date: "2026-01-01", name: "New Year's Day" },
+    { date: "2026-01-19", name: "Martin Luther King Jr. Day" },
+    { date: "2026-02-16", name: "Presidents Day" },
+    { date: "2026-04-03", name: "Good Friday" },
+    { date: "2026-05-25", name: "Memorial Day" },
+    { date: "2026-06-19", name: "Juneteenth" },
+    { date: "2026-07-03", name: "Independence Day (observed)" },
+    { date: "2026-09-07", name: "Labor Day" },
+    { date: "2026-11-26", name: "Thanksgiving" },
+    { date: "2026-12-25", name: "Christmas" },
+];
+const ALL_NYSE_HOLIDAYS = [
+    ...NYSE_HOLIDAYS_2025,
+    ...NYSE_HOLIDAYS_2026,
+];
+// ============================================================================
+// Market Schedules
+// All times are in EST (UTC-5), adjusted for EDT (UTC-4) when DST is active
+// ============================================================================
+const CRYPTO_SCHEDULE = {
+    marketType: "crypto",
+    sessions: [], // 24/7, no session boundaries
+    holidays: [],
+};
+// Forex: Sunday 5:00 PM ET → Friday 5:00 PM ET
+// EST: Sunday 22:00 UTC → Friday 22:00 UTC
+// EDT: Sunday 21:00 UTC → Friday 21:00 UTC
+const FOREX_SCHEDULE = {
+    marketType: "forex",
+    sessions: [
+        // Represented as: opens Sunday evening, closes Friday evening
+        { dayOfWeek: 0, openTimeUTC: "22:00", closeTimeUTC: "23:59" }, // Sunday open
+        { dayOfWeek: 1, openTimeUTC: "00:00", closeTimeUTC: "23:59" }, // Monday
+        { dayOfWeek: 2, openTimeUTC: "00:00", closeTimeUTC: "23:59" }, // Tuesday
+        { dayOfWeek: 3, openTimeUTC: "00:00", closeTimeUTC: "23:59" }, // Wednesday
+        { dayOfWeek: 4, openTimeUTC: "00:00", closeTimeUTC: "23:59" }, // Thursday
+        { dayOfWeek: 5, openTimeUTC: "00:00", closeTimeUTC: "22:00" }, // Friday close
+    ],
+    holidays: [
+        { date: "2025-12-25", name: "Christmas" },
+        { date: "2026-12-25", name: "Christmas" },
+    ],
+};
+// US Stocks: Weekdays 9:30 AM - 4:00 PM ET
+// EST: 14:30 - 21:00 UTC
+// EDT: 13:30 - 20:00 UTC
+const STOCKS_SCHEDULE = {
+    marketType: "stocks",
+    sessions: [
+        { dayOfWeek: 1, openTimeUTC: "14:30", closeTimeUTC: "21:00" }, // Monday
+        { dayOfWeek: 2, openTimeUTC: "14:30", closeTimeUTC: "21:00" }, // Tuesday
+        { dayOfWeek: 3, openTimeUTC: "14:30", closeTimeUTC: "21:00" }, // Wednesday
+        { dayOfWeek: 4, openTimeUTC: "14:30", closeTimeUTC: "21:00" }, // Thursday
+        { dayOfWeek: 5, openTimeUTC: "14:30", closeTimeUTC: "21:00" }, // Friday
+    ],
+    holidays: ALL_NYSE_HOLIDAYS,
+};
+// Commodities: Sunday 6:00 PM ET → Friday 5:00 PM ET with daily 5-6 PM break
+// EST: Sunday 23:00 UTC → Friday 22:00 UTC, daily break 22:00-23:00 UTC
+// EDT: Sunday 22:00 UTC → Friday 21:00 UTC, daily break 21:00-22:00 UTC
+const COMMODITIES_SCHEDULE = {
+    marketType: "commodities",
+    sessions: [
+        { dayOfWeek: 0, openTimeUTC: "23:00", closeTimeUTC: "23:59" }, // Sunday open
+        { dayOfWeek: 1, openTimeUTC: "00:00", closeTimeUTC: "22:00" }, // Monday (break at 22:00)
+        { dayOfWeek: 1, openTimeUTC: "23:00", closeTimeUTC: "23:59" }, // Monday reopen
+        { dayOfWeek: 2, openTimeUTC: "00:00", closeTimeUTC: "22:00" }, // Tuesday
+        { dayOfWeek: 2, openTimeUTC: "23:00", closeTimeUTC: "23:59" }, // Tuesday reopen
+        { dayOfWeek: 3, openTimeUTC: "00:00", closeTimeUTC: "22:00" }, // Wednesday
+        { dayOfWeek: 3, openTimeUTC: "23:00", closeTimeUTC: "23:59" }, // Wednesday reopen
+        { dayOfWeek: 4, openTimeUTC: "00:00", closeTimeUTC: "22:00" }, // Thursday
+        { dayOfWeek: 4, openTimeUTC: "23:00", closeTimeUTC: "23:59" }, // Thursday reopen
+        { dayOfWeek: 5, openTimeUTC: "00:00", closeTimeUTC: "22:00" }, // Friday close
+    ],
+    holidays: [
+        { date: "2025-12-25", name: "Christmas" },
+        { date: "2026-12-25", name: "Christmas" },
+    ],
+    dailyBreaks: [
+        { startTimeUTC: "22:00", endTimeUTC: "23:00", daysOfWeek: [1, 2, 3, 4] },
+    ],
+};
+// ============================================================================
+// Group ID to Market Type Mapping
+// ============================================================================
+const GROUP_ID_TO_MARKET_TYPE = {
+    [groupIds_1.GROUP_CONFIGS_IDS.basicCryptoGroup]: "crypto",
+    [groupIds_1.GROUP_CONFIGS_IDS.catCryptoGroup]: "crypto",
+    [groupIds_1.GROUP_CONFIGS_IDS.forexGroup]: "forex",
+    [groupIds_1.GROUP_CONFIGS_IDS.catForexGroup]: "forex",
+    [groupIds_1.GROUP_CONFIGS_IDS.stocksGroup]: "stocks",
+    [groupIds_1.GROUP_CONFIGS_IDS.catStocksGroup]: "stocks",
+    [groupIds_1.GROUP_CONFIGS_IDS.commoditiesGroup]: "commodities",
+    [groupIds_1.GROUP_CONFIGS_IDS.catCommoditiesGroup]: "commodities",
+};
+const MARKET_TYPE_TO_SCHEDULE = {
+    crypto: CRYPTO_SCHEDULE,
+    forex: FOREX_SCHEDULE,
+    stocks: STOCKS_SCHEDULE,
+    commodities: COMMODITIES_SCHEDULE,
+};
+function getMarketTypeFromGroupId(groupId) {
+    const marketType = GROUP_ID_TO_MARKET_TYPE[groupId];
+    if (!marketType) {
+        throw new Error(`Unknown group ID: ${groupId}`);
+    }
+    return marketType;
+}
+// ============================================================================
+// DST Detection
+// US DST: 2nd Sunday of March 2:00 AM → 1st Sunday of November 2:00 AM
+// ============================================================================
+/**
+ * Get the nth occurrence of a specific day of week in a month
+ * @param year Full year (e.g., 2025)
+ * @param month Month (0-11)
+ * @param dayOfWeek Day of week (0 = Sunday)
+ * @param n Which occurrence (1 = first, 2 = second, etc.)
+ * @returns Date object for that day at 00:00 UTC
+ */
+function getNthDayOfMonth(year, month, dayOfWeek, n) {
+    const firstDay = new Date(Date.UTC(year, month, 1));
+    const firstDayOfWeek = firstDay.getUTCDay();
+    let dayOffset = dayOfWeek - firstDayOfWeek;
+    if (dayOffset < 0)
+        dayOffset += 7;
+    const nthDay = 1 + dayOffset + (n - 1) * 7;
+    return new Date(Date.UTC(year, month, nthDay));
+}
+/**
+ * Check if a given timestamp falls within US Daylight Saving Time
+ * DST starts: 2nd Sunday of March at 2:00 AM local (7:00 UTC)
+ * DST ends: 1st Sunday of November at 2:00 AM local (6:00 UTC)
+ */
+function isUSInDST(timestamp) {
+    const date = new Date(timestamp);
+    const year = date.getUTCFullYear();
+    // DST starts: 2nd Sunday of March at 7:00 UTC (2:00 AM EST → 3:00 AM EDT)
+    const dstStart = getNthDayOfMonth(year, 2, 0, 2); // March, Sunday, 2nd
+    dstStart.setUTCHours(7, 0, 0, 0);
+    // DST ends: 1st Sunday of November at 6:00 UTC (2:00 AM EDT → 1:00 AM EST)
+    const dstEnd = getNthDayOfMonth(year, 10, 0, 1); // November, Sunday, 1st
+    dstEnd.setUTCHours(6, 0, 0, 0);
+    return timestamp >= dstStart.getTime() && timestamp < dstEnd.getTime();
+}
+// ============================================================================
+// Internal Helpers
+// ============================================================================
+function getScheduleForGroupId(groupId) {
+    const marketType = getMarketTypeFromGroupId(groupId);
+    return MARKET_TYPE_TO_SCHEDULE[marketType];
+}
+function parseTimeUTC(timeStr) {
+    const [hours, minutes] = timeStr.split(':').map(Number);
+    return { hours, minutes };
+}
+function adjustTimeForDST(timeStr, isDST) {
+    if (!isDST)
+        return timeStr;
+    const { hours, minutes } = parseTimeUTC(timeStr);
+    const adjustedHours = hours - 1; // DST = 1 hour earlier in UTC
+    return `${adjustedHours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}`;
+}
+function getDateString(timestamp) {
+    const date = new Date(timestamp);
+    const year = date.getUTCFullYear();
+    const month = (date.getUTCMonth() + 1).toString().padStart(2, '0');
+    const day = date.getUTCDate().toString().padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+function isHoliday(timestamp, holidays) {
+    const dateStr = getDateString(timestamp);
+    return holidays.some(h => h.date === dateStr);
+}
+// ============================================================================
+// Public API
+// ============================================================================
+function getMarketStatus(groupId, timestamp) {
+    const ts = timestamp ?? Date.now();
+    const schedule = getScheduleForGroupId(groupId);
+    // Crypto is always open
+    if (schedule.marketType === "crypto") {
+        return {
+            isOpen: true,
+            nextOpen: null,
+            nextClose: null,
+            marketType: "crypto",
+        };
+    }
+    if (schedule.marketType === "stocks") {
+        return getStocksMarketStatus(ts, schedule);
+    }
+    if (schedule.marketType === "forex") {
+        return getForexMarketStatus(ts, schedule);
+    }
+    if (schedule.marketType === "commodities") {
+        return getCommoditiesMarketStatus(ts, schedule);
+    }
+    throw new Error(`Market type ${schedule.marketType} not yet implemented`);
+}
+function getStocksMarketStatus(timestamp, schedule) {
+    const date = new Date(timestamp);
+    const dayOfWeek = date.getUTCDay();
+    const isDST = isUSInDST(timestamp);
+    // Check if it's a holiday
+    if (isHoliday(timestamp, schedule.holidays)) {
+        return {
+            isOpen: false,
+            nextOpen: findNextStocksOpen(timestamp, schedule, isDST),
+            nextClose: null,
+            marketType: "stocks",
+        };
+    }
+    // Check if it's a weekend
+    if (dayOfWeek === 0 || dayOfWeek === 6) {
+        return {
+            isOpen: false,
+            nextOpen: findNextStocksOpen(timestamp, schedule, isDST),
+            nextClose: null,
+            marketType: "stocks",
+        };
+    }
+    // Find today's session
+    const session = schedule.sessions.find(s => s.dayOfWeek === dayOfWeek);
+    if (!session) {
+        return {
+            isOpen: false,
+            nextOpen: findNextStocksOpen(timestamp, schedule, isDST),
+            nextClose: null,
+            marketType: "stocks",
+        };
+    }
+    // Adjust times for DST
+    const openTime = adjustTimeForDST(session.openTimeUTC, isDST);
+    const closeTime = adjustTimeForDST(session.closeTimeUTC, isDST);
+    const { hours: openHours, minutes: openMinutes } = parseTimeUTC(openTime);
+    const { hours: closeHours, minutes: closeMinutes } = parseTimeUTC(closeTime);
+    const currentHours = date.getUTCHours();
+    const currentMinutes = date.getUTCMinutes();
+    const currentTimeMinutes = currentHours * 60 + currentMinutes;
+    const openTimeMinutes = openHours * 60 + openMinutes;
+    const closeTimeMinutes = closeHours * 60 + closeMinutes;
+    if (currentTimeMinutes >= openTimeMinutes && currentTimeMinutes < closeTimeMinutes) {
+        // Market is open
+        const closeDate = new Date(timestamp);
+        closeDate.setUTCHours(closeHours, closeMinutes, 0, 0);
+        return {
+            isOpen: true,
+            nextOpen: null,
+            nextClose: closeDate,
+            marketType: "stocks",
+        };
+    }
+    // Market is closed
+    return {
+        isOpen: false,
+        nextOpen: findNextStocksOpen(timestamp, schedule, isDST),
+        nextClose: null,
+        marketType: "stocks",
+    };
+}
+function findNextStocksOpen(timestamp, schedule, isDST) {
+    const date = new Date(timestamp);
+    let checkDate = new Date(timestamp);
+    // Get the open time (adjusted for DST)
+    const baseOpenTime = schedule.sessions.find(s => s.dayOfWeek === 1).openTimeUTC;
+    const openTime = adjustTimeForDST(baseOpenTime, isDST);
+    const { hours: openHours, minutes: openMinutes } = parseTimeUTC(openTime);
+    // If we're before today's open and today is a trading day, return today's open
+    const currentTimeMinutes = date.getUTCHours() * 60 + date.getUTCMinutes();
+    const openTimeMinutes = openHours * 60 + openMinutes;
+    const dayOfWeek = date.getUTCDay();
+    if (dayOfWeek >= 1 &&
+        dayOfWeek <= 5 &&
+        currentTimeMinutes < openTimeMinutes &&
+        !isHoliday(timestamp, schedule.holidays)) {
+        checkDate.setUTCHours(openHours, openMinutes, 0, 0);
+        return checkDate;
+    }
+    // Otherwise, find the next trading day
+    checkDate.setUTCDate(checkDate.getUTCDate() + 1);
+    checkDate.setUTCHours(openHours, openMinutes, 0, 0);
+    // Loop until we find a valid trading day (max 10 days to prevent infinite loop)
+    for (let i = 0; i < 10; i++) {
+        const checkDayOfWeek = checkDate.getUTCDay();
+        // Skip weekends
+        if (checkDayOfWeek === 0) {
+            checkDate.setUTCDate(checkDate.getUTCDate() + 1);
+            continue;
+        }
+        if (checkDayOfWeek === 6) {
+            checkDate.setUTCDate(checkDate.getUTCDate() + 2);
+            continue;
+        }
+        // Check DST for the check date and adjust if needed
+        const checkIsDST = isUSInDST(checkDate.getTime());
+        if (checkIsDST !== isDST) {
+            const newOpenTime = adjustTimeForDST(baseOpenTime, checkIsDST);
+            const { hours: newOpenHours, minutes: newOpenMinutes } = parseTimeUTC(newOpenTime);
+            checkDate.setUTCHours(newOpenHours, newOpenMinutes, 0, 0);
+        }
+        // Skip holidays
+        if (isHoliday(checkDate.getTime(), schedule.holidays)) {
+            checkDate.setUTCDate(checkDate.getUTCDate() + 1);
+            continue;
+        }
+        return checkDate;
+    }
+    return checkDate;
+}
+function getForexMarketStatus(timestamp, schedule) {
+    const date = new Date(timestamp);
+    const dayOfWeek = date.getUTCDay();
+    const isDST = isUSInDST(timestamp);
+    // Forex hours (EST): Sunday 22:00 UTC → Friday 22:00 UTC
+    // EDT adjustment: Sunday 21:00 UTC → Friday 21:00 UTC
+    const openHour = isDST ? 21 : 22;
+    const closeHour = isDST ? 21 : 22;
+    // Check if holiday
+    if (isHoliday(timestamp, schedule.holidays)) {
+        return {
+            isOpen: false,
+            nextOpen: findNextForexOpen(timestamp, isDST),
+            nextClose: null,
+            marketType: "forex",
+        };
+    }
+    const currentHours = date.getUTCHours();
+    // Saturday: always closed
+    if (dayOfWeek === 6) {
+        return {
+            isOpen: false,
+            nextOpen: findNextForexOpen(timestamp, isDST),
+            nextClose: null,
+            marketType: "forex",
+        };
+    }
+    // Sunday: open after openHour
+    if (dayOfWeek === 0) {
+        if (currentHours >= openHour) {
+            // Find Friday close time
+            const fridayClose = new Date(timestamp);
+            fridayClose.setUTCDate(fridayClose.getUTCDate() + 5); // Next Friday
+            fridayClose.setUTCHours(closeHour, 0, 0, 0);
+            return {
+                isOpen: true,
+                nextOpen: null,
+                nextClose: fridayClose,
+                marketType: "forex",
+            };
+        }
+        else {
+            return {
+                isOpen: false,
+                nextOpen: findNextForexOpen(timestamp, isDST),
+                nextClose: null,
+                marketType: "forex",
+            };
+        }
+    }
+    // Friday: closed after closeHour
+    if (dayOfWeek === 5) {
+        if (currentHours >= closeHour) {
+            return {
+                isOpen: false,
+                nextOpen: findNextForexOpen(timestamp, isDST),
+                nextClose: null,
+                marketType: "forex",
+            };
+        }
+    }
+    // Monday-Friday (before close): open
+    const fridayClose = new Date(timestamp);
+    fridayClose.setUTCDate(date.getUTCDate() + (5 - dayOfWeek));
+    fridayClose.setUTCHours(closeHour, 0, 0, 0);
+    return {
+        isOpen: true,
+        nextOpen: null,
+        nextClose: fridayClose,
+        marketType: "forex",
+    };
+}
+function findNextForexOpen(timestamp, isDST) {
+    const date = new Date(timestamp);
+    const dayOfWeek = date.getUTCDay();
+    const openHour = isDST ? 21 : 22;
+    // Calculate days until next Sunday
+    let daysUntilSunday = (7 - dayOfWeek) % 7;
+    if (dayOfWeek === 0 && date.getUTCHours() >= openHour) {
+        // It's Sunday after open, next open is next week
+        daysUntilSunday = 7;
+    }
+    if (dayOfWeek === 0 && date.getUTCHours() < openHour) {
+        // It's Sunday before open, open is today
+        daysUntilSunday = 0;
+    }
+    const nextOpen = new Date(timestamp);
+    nextOpen.setUTCDate(date.getUTCDate() + daysUntilSunday);
+    nextOpen.setUTCHours(openHour, 0, 0, 0);
+    // Check DST for the open date
+    const openIsDST = isUSInDST(nextOpen.getTime());
+    if (openIsDST !== isDST) {
+        nextOpen.setUTCHours(openIsDST ? 21 : 22, 0, 0, 0);
+    }
+    return nextOpen;
+}
+// ============================================================================
+// Commodities Market Functions
+// Schedule: Sunday 23:00 UTC (EST) → Friday 22:00 UTC (EST)
+//           Sunday 22:00 UTC (EDT) → Friday 21:00 UTC (EDT)
+// Daily break: 22:00-23:00 UTC (EST) / 21:00-22:00 UTC (EDT) on Mon-Thu
+// ============================================================================
+function getCommoditiesMarketStatus(timestamp, schedule) {
+    const date = new Date(timestamp);
+    const dayOfWeek = date.getUTCDay();
+    const isDST = isUSInDST(timestamp);
+    // Commodities hours (EST): Sunday 23:00 UTC → Friday 22:00 UTC
+    // EDT adjustment: Sunday 22:00 UTC → Friday 21:00 UTC
+    // Daily break (EST): 22:00-23:00 UTC on Mon-Thu
+    // Daily break (EDT): 21:00-22:00 UTC on Mon-Thu
+    const openHour = isDST ? 22 : 23; // Sunday open
+    const closeHour = isDST ? 21 : 22; // Friday close and daily break start
+    const breakEndHour = isDST ? 22 : 23; // Daily break end
+    // Check if holiday
+    if (isHoliday(timestamp, schedule.holidays)) {
+        return {
+            isOpen: false,
+            nextOpen: findNextCommoditiesOpen(timestamp, isDST),
+            nextClose: null,
+            marketType: "commodities",
+        };
+    }
+    const currentHours = date.getUTCHours();
+    // Saturday: always closed
+    if (dayOfWeek === 6) {
+        return {
+            isOpen: false,
+            nextOpen: findNextCommoditiesOpen(timestamp, isDST),
+            nextClose: null,
+            marketType: "commodities",
+        };
+    }
+    // Sunday: open after openHour (23:00 EST / 22:00 EDT)
+    if (dayOfWeek === 0) {
+        if (currentHours >= openHour) {
+            return {
+                isOpen: true,
+                nextOpen: null,
+                nextClose: getNextCommoditiesClose(timestamp, isDST),
+                marketType: "commodities",
+            };
+        }
+        else {
+            return {
+                isOpen: false,
+                nextOpen: findNextCommoditiesOpen(timestamp, isDST),
+                nextClose: null,
+                marketType: "commodities",
+            };
+        }
+    }
+    // Friday: closed after closeHour (22:00 EST / 21:00 EDT)
+    if (dayOfWeek === 5) {
+        if (currentHours >= closeHour) {
+            return {
+                isOpen: false,
+                nextOpen: findNextCommoditiesOpen(timestamp, isDST),
+                nextClose: null,
+                marketType: "commodities",
+            };
+        }
+        // Friday before close - market is open
+        return {
+            isOpen: true,
+            nextOpen: null,
+            nextClose: getNextCommoditiesClose(timestamp, isDST),
+            marketType: "commodities",
+        };
+    }
+    // Monday-Thursday: check for daily break (22:00-23:00 EST / 21:00-22:00 EDT)
+    if (dayOfWeek >= 1 && dayOfWeek <= 4) {
+        // During break
+        if (currentHours >= closeHour && currentHours < breakEndHour) {
+            // During daily break - return next open as end of break
+            const breakEnd = new Date(timestamp);
+            breakEnd.setUTCHours(breakEndHour, 0, 0, 0);
+            return {
+                isOpen: false,
+                nextOpen: breakEnd,
+                nextClose: null,
+                marketType: "commodities",
+            };
+        }
+        // Before break or after break reopens
+        return {
+            isOpen: true,
+            nextOpen: null,
+            nextClose: getNextCommoditiesClose(timestamp, isDST),
+            marketType: "commodities",
+        };
+    }
+    // Should not reach here, but fallback
+    return {
+        isOpen: false,
+        nextOpen: findNextCommoditiesOpen(timestamp, isDST),
+        nextClose: null,
+        marketType: "commodities",
+    };
+}
+function getNextCommoditiesClose(timestamp, isDST) {
+    const date = new Date(timestamp);
+    const dayOfWeek = date.getUTCDay();
+    const currentHours = date.getUTCHours();
+    const closeHour = isDST ? 21 : 22; // Daily break start / Friday close
+    const breakEndHour = isDST ? 22 : 23;
+    // If we're before the daily break on Mon-Thu, the next close is today's break
+    if (dayOfWeek >= 1 && dayOfWeek <= 4) {
+        if (currentHours < closeHour) {
+            // Next close is today's daily break
+            const todayBreak = new Date(timestamp);
+            todayBreak.setUTCHours(closeHour, 0, 0, 0);
+            return todayBreak;
+        }
+        // If we're after the break reopened (>= breakEndHour), next close is tomorrow
+        if (currentHours >= breakEndHour) {
+            if (dayOfWeek === 4) {
+                // Thursday after break - next close is Friday close
+                const fridayClose = new Date(timestamp);
+                fridayClose.setUTCDate(date.getUTCDate() + 1);
+                fridayClose.setUTCHours(closeHour, 0, 0, 0);
+                return fridayClose;
+            }
+            else {
+                // Mon-Wed after break - next close is tomorrow's break
+                const tomorrowBreak = new Date(timestamp);
+                tomorrowBreak.setUTCDate(date.getUTCDate() + 1);
+                tomorrowBreak.setUTCHours(closeHour, 0, 0, 0);
+                return tomorrowBreak;
+            }
+        }
+    }
+    // Friday before close - next close is today
+    if (dayOfWeek === 5 && currentHours < closeHour) {
+        const fridayClose = new Date(timestamp);
+        fridayClose.setUTCHours(closeHour, 0, 0, 0);
+        return fridayClose;
+    }
+    // Sunday after open - next close is Monday's break
+    if (dayOfWeek === 0) {
+        const mondayBreak = new Date(timestamp);
+        mondayBreak.setUTCDate(date.getUTCDate() + 1);
+        mondayBreak.setUTCHours(closeHour, 0, 0, 0);
+        return mondayBreak;
+    }
+    // Fallback: return next Monday's break
+    const daysUntilMonday = (8 - dayOfWeek) % 7 || 7;
+    const mondayBreak = new Date(timestamp);
+    mondayBreak.setUTCDate(date.getUTCDate() + daysUntilMonday);
+    mondayBreak.setUTCHours(closeHour, 0, 0, 0);
+    return mondayBreak;
+}
+function findNextCommoditiesOpen(timestamp, isDST) {
+    const date = new Date(timestamp);
+    const dayOfWeek = date.getUTCDay();
+    const currentHours = date.getUTCHours();
+    const openHour = isDST ? 22 : 23; // Sunday open
+    const breakEndHour = isDST ? 22 : 23; // Daily break end
+    // During daily break (Mon-Thu) - next open is end of break (same day)
+    const closeHour = isDST ? 21 : 22;
+    if (dayOfWeek >= 1 && dayOfWeek <= 4) {
+        if (currentHours >= closeHour && currentHours < breakEndHour) {
+            const breakEnd = new Date(timestamp);
+            breakEnd.setUTCHours(breakEndHour, 0, 0, 0);
+            return breakEnd;
+        }
+    }
+    // Sunday before open - open is today
+    if (dayOfWeek === 0 && currentHours < openHour) {
+        const sundayOpen = new Date(timestamp);
+        sundayOpen.setUTCHours(openHour, 0, 0, 0);
+        return sundayOpen;
+    }
+    // Calculate days until next Sunday
+    let daysUntilSunday = (7 - dayOfWeek) % 7;
+    if (dayOfWeek === 0 && currentHours >= openHour) {
+        // It's Sunday after open, next open is next week's Sunday
+        daysUntilSunday = 7;
+    }
+    if (daysUntilSunday === 0 && dayOfWeek !== 0) {
+        // Not Sunday, so we need to go to next Sunday
+        daysUntilSunday = 7;
+    }
+    const nextOpen = new Date(timestamp);
+    nextOpen.setUTCDate(date.getUTCDate() + daysUntilSunday);
+    nextOpen.setUTCHours(openHour, 0, 0, 0);
+    // Check DST for the open date and adjust if needed
+    const openIsDST = isUSInDST(nextOpen.getTime());
+    if (openIsDST !== isDST) {
+        nextOpen.setUTCHours(openIsDST ? 22 : 23, 0, 0, 0);
+    }
+    return nextOpen;
+}
+function isMarketOpen(groupId, timestamp) {
+    return getMarketStatus(groupId, timestamp).isOpen;
+}
+function getMarketStatusForPair(pairId, timestamp) {
+    const pairConfig = (0, pairIds_1.getPairConfigsIdentifierFromPairId)(pairId);
+    if (!pairConfig) {
+        throw new Error(`Unknown pair ID: ${pairId}`);
+    }
+    return getMarketStatus(pairConfig.groupId, timestamp);
+}
+function isMarketOpenForPair(pairId, timestamp) {
+    return getMarketStatusForPair(pairId, timestamp).isOpen;
+}
+function getMarketSchedule(groupId) {
+    return getScheduleForGroupId(groupId);
+}
+function getMarketScheduleForPair(pairId) {
+    const pairConfig = (0, pairIds_1.getPairConfigsIdentifierFromPairId)(pairId);
+    if (!pairConfig) {
+        throw new Error(`Unknown pair ID: ${pairId}`);
+    }
+    return getMarketSchedule(pairConfig.groupId);
+}

package/dist/cjs/lib/priceFeeds/flare/flareFeedConstants.js

@@ -29,6 +29,28 @@ exports.FLARE_PAIRS_PRICE_FEED_IDS = {
     [pairIds_1.PAIR_CONFIGS_IDS.NZD_USD_CAT]: "",
     [pairIds_1.PAIR_CONFIGS_IDS.USD_JPY_CAT]: "",
     [pairIds_1.PAIR_CONFIGS_IDS.USD_CHF_CAT]: "",
+    // Stocks (Flare feed IDs to be configured)
+    [pairIds_1.PAIR_CONFIGS_IDS.TSLA_USD]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.AAPL_USD]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.NVDA_USD]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.AMZN_USD]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.GOOGL_USD]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.MSFT_USD]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.META_USD]: "",
+    // Commodities (Flare feed IDs to be configured)
+    [pairIds_1.PAIR_CONFIGS_IDS.GOLD_USD]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.SILVER_USD]: "",
+    // CAT Mode Stocks
+    [pairIds_1.PAIR_CONFIGS_IDS.TSLA_USD_CAT]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.AAPL_USD_CAT]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.NVDA_USD_CAT]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.AMZN_USD_CAT]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.GOOGL_USD_CAT]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.MSFT_USD_CAT]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.META_USD_CAT]: "",
+    // CAT Mode Commodities
+    [pairIds_1.PAIR_CONFIGS_IDS.GOLD_USD_CAT]: "",
+    [pairIds_1.PAIR_CONFIGS_IDS.SILVER_USD_CAT]: "",
 };
 // Reverse mapping
 exports.FLARE_PRICE_FEED_ID_TO_PAIR = Object.entries(exports.FLARE_PAIRS_PRICE_FEED_IDS).reduce((acc, [pairId, feedId]) => {