@discomedia/utils 1.0.32 → 1.0.33

package/dist/test.js

@@ -146,18 +146,12 @@ const marketEarlyCloses = {
 
 // Constants for NY market times (Eastern Time)
 const MARKET_CONFIG = {
-    TIMEZONE: 'America/New_York',
     UTC_OFFSET_STANDARD: -5, // EST
     UTC_OFFSET_DST: -4, // EDT
     TIMES: {
-        EXTENDED_START: { hour: 4, minute: 0 },
         MARKET_OPEN: { hour: 9, minute: 30 },
-        EARLY_MARKET_END: { hour: 10, minute: 0 },
         MARKET_CLOSE: { hour: 16, minute: 0 },
-        EARLY_CLOSE: { hour: 13, minute: 0 },
-        EXTENDED_END: { hour: 20, minute: 0 },
-        EARLY_EXTENDED_END: { hour: 17, minute: 0 },
-    },
+        EARLY_CLOSE: { hour: 13, minute: 0 }},
 };
 // Helper: Get NY offset for a given UTC date (DST rules for US)
 /**
@@ -225,33 +219,6 @@ function fromNYTime(date) {
     const utcMillis = nyMillis - offset * 60 * 60 * 1000;
     return new Date(utcMillis);
 }
-// Helper: Format date in ISO, unix, etc.
-/**
- * Formats a date in ISO, unix-seconds, or unix-ms format.
- * @param date - Date object
- * @param outputFormat - Output format ('iso', 'unix-seconds', 'unix-ms')
- * @returns Formatted date string or number
- */
-function formatDate(date, outputFormat = 'iso') {
-    switch (outputFormat) {
-        case 'unix-seconds':
-            return Math.floor(date.getTime() / 1000);
-        case 'unix-ms':
-            return date.getTime();
-        case 'iso':
-        default:
-            return date.toISOString();
-    }
-}
-// Helper: Format date in NY locale string
-/**
- * Formats a date in NY locale string.
- * @param date - Date object
- * @returns NY locale string
- */
-function formatNYLocale(date) {
-    return date.toLocaleString('en-US', { timeZone: 'America/New_York' });
-}
 // Market calendar logic
 /**
  * Market calendar logic for holidays, weekends, and market days.
@@ -347,82 +314,6 @@ class MarketCalendar {
         return prevDay;
     }
 }
-// Market open/close times
-/**
- * Returns market open/close times for a given date, including extended and early closes.
- * @param date - Date object
- * @returns MarketOpenCloseResult
- */
-function getMarketTimes(date) {
-    const calendar = new MarketCalendar();
-    const nyDate = toNYTime(date);
-    if (!calendar.isMarketDay(date)) {
-        return {
-            marketOpen: false,
-            open: null,
-            close: null,
-            openExt: null,
-            closeExt: null,
-        };
-    }
-    const year = nyDate.getUTCFullYear();
-    const month = nyDate.getUTCMonth();
-    const day = nyDate.getUTCDate();
-    // Helper to build NY time for a given hour/minute
-    function buildNYTime(hour, minute) {
-        const d = new Date(Date.UTC(year, month, day, hour, minute, 0, 0));
-        return fromNYTime(d);
-    }
-    let open = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute);
-    let close = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute);
-    let openExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute);
-    let closeExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute);
-    if (calendar.isEarlyCloseDay(date)) {
-        close = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute);
-        closeExt = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute);
-    }
-    return {
-        marketOpen: true,
-        open,
-        close,
-        openExt,
-        closeExt,
-    };
-}
-// Is within market hours
-/**
- * Checks if a date/time is within market hours, extended hours, or continuous.
- * @param date - Date object
- * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
- * @returns true if within hours, false otherwise
- */
-function isWithinMarketHours(date, intradayReporting = 'market_hours') {
-    const calendar = new MarketCalendar();
-    if (!calendar.isMarketDay(date))
-        return false;
-    const nyDate = toNYTime(date);
-    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
-    switch (intradayReporting) {
-        case 'extended_hours': {
-            let endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
-            if (calendar.isEarlyCloseDay(date)) {
-                endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
-            }
-            const startMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
-            return minutes >= startMinutes && minutes <= endMinutes;
-        }
-        case 'continuous':
-            return true;
-        default: {
-            let endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-            if (calendar.isEarlyCloseDay(date)) {
-                endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-            }
-            const startMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-            return minutes >= startMinutes && minutes <= endMinutes;
-        }
-    }
-}
 // Get last full trading date
 /**
  * Returns the last full trading date (market close) for a given date.
@@ -462,244 +353,6 @@ function getLastFullTradingDateImpl(currentDate = new Date()) {
     const closeMinute = marketCloseMinutes % 60;
     return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
 }
-// Get day boundaries
-/**
- * Returns the start and end boundaries for a market day, extended hours, or continuous.
- * @param date - Date object
- * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
- * @returns Object with start and end Date
- */
-function getDayBoundaries(date, intradayReporting = 'market_hours') {
-    const calendar = new MarketCalendar();
-    const nyDate = toNYTime(date);
-    const year = nyDate.getUTCFullYear();
-    const month = nyDate.getUTCMonth();
-    const day = nyDate.getUTCDate();
-    function buildNYTime(hour, minute, sec = 0, ms = 0) {
-        const d = new Date(Date.UTC(year, month, day, hour, minute, sec, ms));
-        return fromNYTime(d);
-    }
-    let start;
-    let end;
-    switch (intradayReporting) {
-        case 'extended_hours':
-            start = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute, 0, 0);
-            end = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute, 59, 999);
-            if (calendar.isEarlyCloseDay(date)) {
-                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute, 59, 999);
-            }
-            break;
-        case 'continuous':
-            start = new Date(Date.UTC(year, month, day, 0, 0, 0, 0));
-            end = new Date(Date.UTC(year, month, day, 23, 59, 59, 999));
-            break;
-        default:
-            start = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute, 0, 0);
-            end = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute, 59, 999);
-            if (calendar.isEarlyCloseDay(date)) {
-                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute, 59, 999);
-            }
-            break;
-    }
-    return { start, end };
-}
-// Period calculator
-/**
- * Calculates the start date for a given period ending at endDate.
- * @param endDate - Date object
- * @param period - Period string
- * @returns Date object for period start
- */
-function calculatePeriodStartDate(endDate, period) {
-    const calendar = new MarketCalendar();
-    let startDate;
-    switch (period) {
-        case 'YTD':
-            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), 0, 1));
-            break;
-        case '1D':
-            startDate = calendar.getPreviousMarketDay(endDate);
-            break;
-        case '3D':
-            startDate = new Date(endDate.getTime() - 3 * 24 * 60 * 60 * 1000);
-            break;
-        case '1W':
-            startDate = new Date(endDate.getTime() - 7 * 24 * 60 * 60 * 1000);
-            break;
-        case '2W':
-            startDate = new Date(endDate.getTime() - 14 * 24 * 60 * 60 * 1000);
-            break;
-        case '1M':
-            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 1, endDate.getUTCDate()));
-            break;
-        case '3M':
-            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 3, endDate.getUTCDate()));
-            break;
-        case '6M':
-            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 6, endDate.getUTCDate()));
-            break;
-        case '1Y':
-            startDate = new Date(Date.UTC(endDate.getUTCFullYear() - 1, endDate.getUTCMonth(), endDate.getUTCDate()));
-            break;
-        default:
-            throw new Error(`Invalid period: ${period}`);
-    }
-    // Ensure start date is a market day
-    while (!calendar.isMarketDay(startDate)) {
-        startDate = calendar.getNextMarketDay(startDate);
-    }
-    return startDate;
-}
-// Get market time period
-/**
- * Returns the start and end dates for a market time period.
- * @param params - MarketTimeParams
- * @returns PeriodDates object
- */
-function getMarketTimePeriod(params) {
-    const { period, end = new Date(), intraday_reporting = 'market_hours', outputFormat = 'iso' } = params;
-    if (!period)
-        throw new Error('Period is required');
-    const calendar = new MarketCalendar();
-    const nyEndDate = toNYTime(end);
-    let endDate;
-    const isCurrentMarketDay = calendar.isMarketDay(end);
-    const isWithinHours = isWithinMarketHours(end, intraday_reporting);
-    const minutes = nyEndDate.getUTCHours() * 60 + nyEndDate.getUTCMinutes();
-    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-    if (isCurrentMarketDay) {
-        if (minutes < marketStartMinutes) {
-            // Before market open - use previous day's close
-            const lastMarketDay = calendar.getPreviousMarketDay(end);
-            const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
-            endDate = dayEnd;
-        }
-        else if (isWithinHours) {
-            // During market hours - use current time
-            endDate = end;
-        }
-        else {
-            // After market close - use today's close
-            const { end: dayEnd } = getDayBoundaries(end, intraday_reporting);
-            endDate = dayEnd;
-        }
-    }
-    else {
-        // Not a market day - use previous market day's close
-        const lastMarketDay = calendar.getPreviousMarketDay(end);
-        const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
-        endDate = dayEnd;
-    }
-    // Calculate start date
-    const periodStartDate = calculatePeriodStartDate(endDate, period);
-    const { start: dayStart } = getDayBoundaries(periodStartDate, intraday_reporting);
-    if (endDate.getTime() < dayStart.getTime()) {
-        throw new Error('Start date cannot be after end date');
-    }
-    return {
-        start: formatDate(dayStart, outputFormat),
-        end: formatDate(endDate, outputFormat),
-    };
-}
-// Market status
-/**
- * Returns the current market status for a given date.
- * @param date - Date object (default: now)
- * @returns MarketStatus object
- */
-function getMarketStatusImpl(date = new Date()) {
-    const calendar = new MarketCalendar();
-    const nyDate = toNYTime(date);
-    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
-    const isMarketDay = calendar.isMarketDay(date);
-    const isEarlyCloseDay = calendar.isEarlyCloseDay(date);
-    const extendedStartMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
-    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-    const earlyMarketEndMinutes = MARKET_CONFIG.TIMES.EARLY_MARKET_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_MARKET_END.minute;
-    let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-    let extendedEndMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
-    if (isEarlyCloseDay) {
-        marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-        extendedEndMinutes =
-            MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
-    }
-    let status;
-    let nextStatus;
-    let nextStatusTime;
-    let marketPeriod;
-    if (!isMarketDay) {
-        status = 'closed';
-        nextStatus = 'extended hours';
-        marketPeriod = 'closed';
-        const nextMarketDay = calendar.getNextMarketDay(date);
-        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
-    }
-    else if (minutes < extendedStartMinutes) {
-        status = 'closed';
-        nextStatus = 'extended hours';
-        marketPeriod = 'closed';
-        nextStatusTime = getDayBoundaries(date, 'extended_hours').start;
-    }
-    else if (minutes < marketStartMinutes) {
-        status = 'extended hours';
-        nextStatus = 'open';
-        marketPeriod = 'preMarket';
-        nextStatusTime = getDayBoundaries(date, 'market_hours').start;
-    }
-    else if (minutes < marketCloseMinutes) {
-        status = 'open';
-        nextStatus = 'extended hours';
-        marketPeriod = minutes < earlyMarketEndMinutes ? 'earlyMarket' : 'regularMarket';
-        nextStatusTime = getDayBoundaries(date, 'market_hours').end;
-    }
-    else if (minutes < extendedEndMinutes) {
-        status = 'extended hours';
-        nextStatus = 'closed';
-        marketPeriod = 'afterMarket';
-        nextStatusTime = getDayBoundaries(date, 'extended_hours').end;
-    }
-    else {
-        status = 'closed';
-        nextStatus = 'extended hours';
-        marketPeriod = 'closed';
-        const nextMarketDay = calendar.getNextMarketDay(date);
-        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
-    }
-    // I think using nyDate here may be wrong - should use current time? i.e. date.getTime()
-    const nextStatusTimeDifference = nextStatusTime.getTime() - date.getTime();
-    return {
-        time: date,
-        timeString: formatNYLocale(nyDate),
-        status,
-        nextStatus,
-        marketPeriod,
-        nextStatusTime,
-        nextStatusTimeDifference,
-        nextStatusTimeString: formatNYLocale(nextStatusTime),
-    };
-}
-// API exports
-/**
- * Returns market open/close times for a given date.
- * @param options - { date?: Date }
- * @returns MarketOpenCloseResult
- */
-function getMarketOpenClose(options = {}) {
-    const { date = new Date() } = options;
-    return getMarketTimes(date);
-}
-/**
- * Returns the start and end dates for a market time period as Date objects.
- * @param params - MarketTimeParams
- * @returns Object with start and end Date
- */
-function getStartAndEndDates(params = {}) {
-    const { start, end } = getMarketTimePeriod(params);
-    return {
-        start: typeof start === 'string' || typeof start === 'number' ? new Date(start) : start,
-        end: typeof end === 'string' || typeof end === 'number' ? new Date(end) : end,
-    };
-}
 /**
  * Returns the last full trading date as a Date object.
  */
@@ -711,230 +364,6 @@ function getStartAndEndDates(params = {}) {
 function getLastFullTradingDate(currentDate = new Date()) {
     return getLastFullTradingDateImpl(currentDate);
 }
-/**
- * Returns the next market day after the reference date.
- * @param referenceDate - Date object (default: now)
- * @returns Object with date, yyyymmdd string, and ISO string
- */
-function getNextMarketDay({ referenceDate } = {}) {
-    const calendar = new MarketCalendar();
-    const startDate = referenceDate ?? new Date();
-    // Find the next trading day (UTC Date object)
-    const nextDate = calendar.getNextMarketDay(startDate);
-    // Convert to NY time before extracting Y-M-D parts
-    const nyNext = toNYTime(nextDate);
-    const yyyymmdd = `${nyNext.getUTCFullYear()}-${String(nyNext.getUTCMonth() + 1).padStart(2, '0')}-${String(nyNext.getUTCDate()).padStart(2, '0')}`;
-    return {
-        date: nextDate, // raw Date, unchanged
-        yyyymmdd, // correct trading date string
-        dateISOString: nextDate.toISOString(),
-    };
-}
-/**
- * Returns the previous market day before the reference date.
- * @param referenceDate - Date object (default: now)
- * @returns Object with date, yyyymmdd string, and ISO string
- */
-function getPreviousMarketDay({ referenceDate } = {}) {
-    const calendar = new MarketCalendar();
-    const startDate = referenceDate || new Date();
-    const prevDate = calendar.getPreviousMarketDay(startDate);
-    // convert to NY time first
-    const nyPrev = toNYTime(prevDate); // ← already in this file
-    const yyyymmdd = `${nyPrev.getUTCFullYear()}-${String(nyPrev.getUTCMonth() + 1).padStart(2, '0')}-${String(nyPrev.getUTCDate()).padStart(2, '0')}`;
-    return {
-        date: prevDate,
-        yyyymmdd,
-        dateISOString: prevDate.toISOString(),
-    };
-}
-/**
- * Returns the trading date for a given time. Note: Just trims the date string; does not validate if the date is a market day.
- * @param time - a string, number (unix timestamp), or Date object representing the time
- * @returns the trading date as a string in YYYY-MM-DD format
- */
-/**
- * Returns the trading date for a given time in YYYY-MM-DD format (NY time).
- * @param time - string, number, or Date
- * @returns trading date string
- */
-function getTradingDate(time) {
-    const date = typeof time === 'number' ? new Date(time) : typeof time === 'string' ? new Date(time) : time;
-    const nyDate = toNYTime(date);
-    return `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
-}
-/**
- * Returns the NY timezone offset string for a given date.
- * @param date - Date object (default: now)
- * @returns '-04:00' for EDT, '-05:00' for EST
- */
-function getNYTimeZone(date) {
-    const offset = getNYOffset(date || new Date());
-    return offset === -4 ? '-04:00' : '-05:00';
-}
-/**
- * Returns the current market status for a given date.
- * @param options - { date?: Date }
- * @returns MarketStatus object
- */
-function getMarketStatus(options = {}) {
-    const { date = new Date() } = options;
-    return getMarketStatusImpl(date);
-}
-/**
- * Checks if a date is a market day.
- * @param date - Date object
- * @returns true if market day, false otherwise
- */
-function isMarketDay(date) {
-    const calendar = new MarketCalendar();
-    return calendar.isMarketDay(date);
-}
-/**
- * Returns full trading days from market open to market close.
- * endDate is always the most recent market close (previous day's close if before open, today's close if after open).
- * days: 1 or not specified = that day's open; 2 = previous market day's open, etc.
- */
-/**
- * Returns full trading days from market open to market close.
- * @param options - { endDate?: Date, days?: number }
- * @returns Object with startDate and endDate
- */
-function getTradingStartAndEndDates(options = {}) {
-    const { endDate = new Date(), days = 1 } = options;
-    const calendar = new MarketCalendar();
-    // Find the most recent market close
-    let endMarketDay = endDate;
-    const nyEnd = toNYTime(endDate);
-    const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-    const marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-    const minutes = nyEnd.getUTCHours() * 60 + nyEnd.getUTCMinutes();
-    if (!calendar.isMarketDay(endDate) ||
-        minutes < marketOpenMinutes ||
-        (minutes >= marketOpenMinutes && minutes < marketCloseMinutes)) {
-        // Before market open, not a market day, or during market hours: use previous market day
-        endMarketDay = calendar.getPreviousMarketDay(endDate);
-    }
-    else {
-        // After market close: use today
-        endMarketDay = endDate;
-    }
-    // Get market close for endMarketDay
-    const endClose = getMarketOpenClose({ date: endMarketDay }).close;
-    // Find start market day by iterating back over market days
-    let startMarketDay = endMarketDay;
-    let count = Math.max(1, days);
-    for (let i = 1; i < count; i++) {
-        startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
-    }
-    // If days > 1, we need to go back (days-1) market days from endMarketDay
-    if (days > 1) {
-        startMarketDay = endMarketDay;
-        for (let i = 1; i < days; i++) {
-            startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
-        }
-    }
-    const startOpen = getMarketOpenClose({ date: startMarketDay }).open;
-    return { startDate: startOpen, endDate: endClose };
-}
-/**
- * Counts trading time between two dates (passed as standard Date objects), excluding weekends and holidays, and closed market hours, using other functions in this library.
- *
- * This function calculates the actual trading time between two dates by:
- * 1. Iterating through each calendar day between startDate and endDate (inclusive)
- * 2. For each day that is a market day (not weekend/holiday), getting market open/close times
- * 3. Calculating the overlap between the time range and market hours for that day
- * 4. Summing up all the trading minutes across all days
- *
- * The function automatically handles:
- * - Weekends (Saturday/Sunday) - skipped entirely
- * - Market holidays - skipped entirely
- * - Early close days (e.g. day before holidays) - uses early close time
- * - Times outside market hours - only counts time within 9:30am-4pm ET (or early close)
- *
- * Examples:
- * - 12pm to 3:30pm same day = 3.5 hours = 210 minutes = 0.54 days
- * - 9:30am to 4pm same day = 6.5 hours = 390 minutes = 1 day
- * - Friday 2pm to Monday 2pm = 6.5 hours (Friday 2pm-4pm + Monday 9:30am-2pm)
- *
- * @param startDate - Start date/time
- * @param endDate - End date/time (default: now)
- * @returns Object containing:
- *   - days: Trading time as fraction of full trading days (6.5 hours = 1 day)
- *   - hours: Trading time in hours
- *   - minutes: Trading time in minutes
- */
-function countTradingDays(startDate, endDate = new Date()) {
-    const calendar = new MarketCalendar();
-    // Ensure start is before end
-    if (startDate.getTime() > endDate.getTime()) {
-        throw new Error('Start date must be before end date');
-    }
-    let totalMinutes = 0;
-    // Get the NY dates for iteration
-    const startNY = toNYTime(startDate);
-    const endNY = toNYTime(endDate);
-    // Create date at start of first day (in NY time)
-    const currentNY = new Date(Date.UTC(startNY.getUTCFullYear(), startNY.getUTCMonth(), startNY.getUTCDate(), 0, 0, 0, 0));
-    // Iterate through each calendar day
-    while (currentNY.getTime() <= endNY.getTime()) {
-        const currentUTC = fromNYTime(currentNY);
-        // Check if this is a market day
-        if (calendar.isMarketDay(currentUTC)) {
-            // Get market hours for this day
-            const marketTimes = getMarketTimes(currentUTC);
-            if (marketTimes.marketOpen && marketTimes.open && marketTimes.close) {
-                // Calculate the overlap between our time range and market hours
-                const dayStart = Math.max(startDate.getTime(), marketTimes.open.getTime());
-                const dayEnd = Math.min(endDate.getTime(), marketTimes.close.getTime());
-                // Only count if there's actual overlap
-                if (dayStart < dayEnd) {
-                    totalMinutes += (dayEnd - dayStart) / (1000 * 60);
-                }
-            }
-        }
-        // Move to next day
-        currentNY.setUTCDate(currentNY.getUTCDate() + 1);
-    }
-    // Convert to days, hours, minutes
-    const MINUTES_PER_TRADING_DAY = 390; // 6.5 hours
-    const days = totalMinutes / MINUTES_PER_TRADING_DAY;
-    const hours = totalMinutes / 60;
-    const minutes = totalMinutes;
-    return {
-        days: Math.round(days * 1000) / 1000, // Round to 3 decimal places
-        hours: Math.round(hours * 100) / 100, // Round to 2 decimal places
-        minutes: Math.round(minutes),
-    };
-}
-// Export MARKET_TIMES for compatibility
-const MARKET_TIMES = {
-    TIMEZONE: MARKET_CONFIG.TIMEZONE,
-    PRE: {
-        START: { HOUR: 4, MINUTE: 0, MINUTES: 240 },
-        END: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
-    },
-    EARLY_MORNING: {
-        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
-        END: { HOUR: 10, MINUTE: 0, MINUTES: 600 },
-    },
-    EARLY_CLOSE_BEFORE_HOLIDAY: {
-        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
-        END: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
-    },
-    EARLY_EXTENDED_BEFORE_HOLIDAY: {
-        START: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
-        END: { HOUR: 17, MINUTE: 0, MINUTES: 1020 },
-    },
-    REGULAR: {
-        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
-        END: { HOUR: 16, MINUTE: 0, MINUTES: 960 },
-    },
-    EXTENDED: {
-        START: { HOUR: 4, MINUTE: 0, MINUTES: 240 },
-        END: { HOUR: 20, MINUTE: 0, MINUTES: 1200 },
-    },
-};
 
 /*
 How it works:
@@ -13457,6 +12886,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
     dataURL;
     apiURL;
     v1beta1url;
+    v1beta3url;
     stockStreamUrl = 'wss://stream.data.alpaca.markets/v2/sip'; // production values
     optionStreamUrl = 'wss://stream.data.alpaca.markets/v1beta3/options'; // production values
     stockWs = null;
@@ -13499,6 +12929,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 ? 'https://paper-api.alpaca.markets/v2'
                 : 'https://api.alpaca.markets/v2'; // used by some, e.g. getAssets
         this.v1beta1url = 'https://data.alpaca.markets/v1beta1'; // used for options endpoints
+        this.v1beta3url = 'https://data.alpaca.markets/v1beta3'; // used for crypto endpoints
         this.setMode('production'); // sets stockStreamUrl and optionStreamUrl
         this.headers = {
             'APCA-API-KEY-ID': process.env.ALPACA_API_KEY,
@@ -13636,7 +13067,9 @@ class AlpacaMarketDataAPI extends EventEmitter {
         }
     }
     async makeRequest(endpoint, method = 'GET', params, baseUrlName = 'data') {
-        const baseUrl = baseUrlName === 'data' ? this.dataURL : baseUrlName === 'api' ? this.apiURL : this.v1beta1url;
+        const baseUrl = baseUrlName === 'data' ? this.dataURL :
+            baseUrlName === 'api' ? this.apiURL :
+                baseUrlName === 'v1beta1' ? this.v1beta1url : this.v1beta3url;
         const url = new URL(`${baseUrl}${endpoint}`);
         try {
             if (params) {
@@ -14344,126 +13777,469 @@ class AlpacaMarketDataAPI extends EventEmitter {
         }
         return newsArticles;
     }
+    // ===== CRYPTO MARKET DATA METHODS =====
+    /**
+     * Get historical OHLCV bars for crypto symbols
+     * Automatically handles pagination to fetch all available data
+     * @param params Parameters for crypto historical bars request
+     * @returns Historical bars data with all pages combined
+     */
+    async getCryptoHistoricalBars(params) {
+        const symbols = params.symbols;
+        const symbolsStr = symbols.join(',');
+        let allBars = {};
+        let pageToken = null;
+        let hasMorePages = true;
+        let totalBarsCount = 0;
+        let pageCount = 0;
+        // Initialize bar arrays for each symbol
+        symbols.forEach((symbol) => {
+            allBars[symbol] = [];
+        });
+        log(`Starting crypto historical bars fetch for ${symbols.length} symbols (${params.timeframe}, ${params.start || 'no start'} to ${params.end || 'no end'})`, { type: 'info' });
+        while (hasMorePages) {
+            pageCount++;
+            const requestParams = {
+                ...params,
+                symbols: symbolsStr,
+                ...(pageToken && { page_token: pageToken }),
+            };
+            const response = await this.makeRequest('/crypto/us/bars', 'GET', requestParams, 'v1beta3');
+            if (!response.bars) {
+                log(`No crypto bars data found in response for ${symbols.length} symbols`, { type: 'warn' });
+                break;
+            }
+            // Combine bars for each symbol
+            let pageBarsCount = 0;
+            Object.entries(response.bars).forEach(([symbol, bars]) => {
+                if (bars && bars.length > 0) {
+                    allBars[symbol] = [...allBars[symbol], ...bars];
+                    pageBarsCount += bars.length;
+                }
+            });
+            totalBarsCount += pageBarsCount;
+            pageToken = response.next_page_token || null;
+            hasMorePages = !!pageToken;
+            log(`Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} crypto bars (total: ${totalBarsCount.toLocaleString()}) for ${symbols.length} symbols${hasMorePages ? ', more pages available' : ', complete'}`);
+            // Prevent infinite loops
+            if (pageCount > 1000) {
+                log(`Stopping crypto bars pagination after ${pageCount} pages to prevent infinite loop`, { type: 'warn' });
+                break;
+            }
+        }
+        log(`Crypto historical bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages`, { type: 'info' });
+        return {
+            bars: allBars,
+            next_page_token: null, // Always null since we fetch all pages
+        };
+    }
+    /**
+     * Get the most recent minute bar for requested crypto symbols
+     * @param symbols Array of crypto symbols to query
+     * @returns Latest bar data for each symbol
+     */
+    async getCryptoLatestBars(symbols) {
+        return this.makeRequest('/crypto/us/latest/bars', 'GET', { symbols: symbols.join(',') }, 'v1beta3');
+    }
+    /**
+     * Get historical quotes for crypto symbols
+     * Automatically handles pagination to fetch all available data
+     * @param params Parameters for crypto historical quotes request
+     * @returns Historical quotes data with all pages combined
+     */
+    async getCryptoHistoricalQuotes(params) {
+        const symbols = params.symbols;
+        const symbolsStr = symbols.join(',');
+        let allQuotes = {};
+        let pageToken = null;
+        let hasMorePages = true;
+        let totalQuotesCount = 0;
+        let pageCount = 0;
+        // Initialize quotes arrays for each symbol
+        symbols.forEach((symbol) => {
+            allQuotes[symbol] = [];
+        });
+        log(`Starting crypto historical quotes fetch for ${symbols.length} symbols (${params.start || 'no start'} to ${params.end || 'no end'})`, { type: 'info' });
+        while (hasMorePages) {
+            pageCount++;
+            const requestParams = {
+                ...params,
+                symbols: symbolsStr,
+                ...(pageToken && { page_token: pageToken }),
+            };
+            const response = await this.makeRequest('/crypto/us/quotes', 'GET', requestParams, 'v1beta3');
+            if (!response.quotes) {
+                log(`No crypto quotes data found in response for ${symbols.length} symbols`, { type: 'warn' });
+                break;
+            }
+            // Combine quotes for each symbol
+            let pageQuotesCount = 0;
+            Object.entries(response.quotes).forEach(([symbol, quotes]) => {
+                if (quotes && quotes.length > 0) {
+                    allQuotes[symbol] = [...allQuotes[symbol], ...quotes];
+                    pageQuotesCount += quotes.length;
+                }
+            });
+            totalQuotesCount += pageQuotesCount;
+            pageToken = response.next_page_token || null;
+            hasMorePages = !!pageToken;
+            log(`Page ${pageCount}: Fetched ${pageQuotesCount.toLocaleString()} crypto quotes (total: ${totalQuotesCount.toLocaleString()}) for ${symbols.length} symbols${hasMorePages ? ', more pages available' : ', complete'}`);
+            // Prevent infinite loops
+            if (pageCount > 1000) {
+                log(`Stopping crypto quotes pagination after ${pageCount} pages to prevent infinite loop`, { type: 'warn' });
+                break;
+            }
+        }
+        log(`Crypto historical quotes fetch complete: ${totalQuotesCount.toLocaleString()} total quotes across ${pageCount} pages`, { type: 'info' });
+        return {
+            quotes: allQuotes,
+            next_page_token: null, // Always null since we fetch all pages
+        };
+    }
+    /**
+     * Get the most recent quotes for requested crypto symbols
+     * @param symbols Array of crypto symbols to query
+     * @returns Latest quote data for each symbol
+     */
+    async getCryptoLatestQuotes(symbols) {
+        if (!symbols || symbols.length === 0) {
+            log('No symbols provided to getCryptoLatestQuotes, returning empty response', { type: 'warn' });
+            return { quotes: {} };
+        }
+        return this.makeRequest('/crypto/us/latest/quotes', 'GET', { symbols: symbols.join(',') }, 'v1beta3');
+    }
+    /**
+     * Get historical trades for crypto symbols
+     * Automatically handles pagination to fetch all available data
+     * @param params Parameters for crypto historical trades request
+     * @returns Historical trades data with all pages combined
+     */
+    async getCryptoHistoricalTrades(params) {
+        const symbols = params.symbols;
+        const symbolsStr = symbols.join(',');
+        let allTrades = {};
+        let pageToken = null;
+        let hasMorePages = true;
+        let totalTradesCount = 0;
+        let pageCount = 0;
+        // Initialize trades arrays for each symbol
+        symbols.forEach((symbol) => {
+            allTrades[symbol] = [];
+        });
+        log(`Starting crypto historical trades fetch for ${symbols.length} symbols (${params.start || 'no start'} to ${params.end || 'no end'})`, { type: 'info' });
+        while (hasMorePages) {
+            pageCount++;
+            const requestParams = {
+                ...params,
+                symbols: symbolsStr,
+                ...(pageToken && { page_token: pageToken }),
+            };
+            const response = await this.makeRequest('/crypto/us/trades', 'GET', requestParams, 'v1beta3');
+            if (!response.trades) {
+                log(`No crypto trades data found in response for ${symbols.length} symbols`, { type: 'warn' });
+                break;
+            }
+            // Combine trades for each symbol
+            let pageTradesCount = 0;
+            Object.entries(response.trades).forEach(([symbol, trades]) => {
+                if (trades && trades.length > 0) {
+                    allTrades[symbol] = [...allTrades[symbol], ...trades];
+                    pageTradesCount += trades.length;
+                }
+            });
+            totalTradesCount += pageTradesCount;
+            pageToken = response.next_page_token || null;
+            hasMorePages = !!pageToken;
+            log(`Page ${pageCount}: Fetched ${pageTradesCount.toLocaleString()} crypto trades (total: ${totalTradesCount.toLocaleString()}) for ${symbols.length} symbols${hasMorePages ? ', more pages available' : ', complete'}`);
+            // Prevent infinite loops
+            if (pageCount > 1000) {
+                log(`Stopping crypto trades pagination after ${pageCount} pages to prevent infinite loop`, { type: 'warn' });
+                break;
+            }
+        }
+        log(`Crypto historical trades fetch complete: ${totalTradesCount.toLocaleString()} total trades across ${pageCount} pages`, { type: 'info' });
+        return {
+            trades: allTrades,
+            next_page_token: null, // Always null since we fetch all pages
+        };
+    }
+    /**
+     * Get the most recent trades for requested crypto symbols
+     * @param symbols Array of crypto symbols to query
+     * @returns Latest trade data for each symbol
+     */
+    async getCryptoLatestTrades(symbols) {
+        if (!symbols || symbols.length === 0) {
+            log('No symbols provided to getCryptoLatestTrades, returning empty response', { type: 'warn' });
+            return { trades: {} };
+        }
+        return this.makeRequest('/crypto/us/latest/trades', 'GET', { symbols: symbols.join(',') }, 'v1beta3');
+    }
+    /**
+     * Get snapshots for crypto symbols
+     * Returns the latest trade, latest quote, latest minute bar, latest daily bar, and previous daily bar data
+     * @param symbols Array of crypto symbols to query
+     * @returns Snapshot data for each symbol
+     */
+    async getCryptoSnapshots(symbols) {
+        if (!symbols || symbols.length === 0) {
+            log('No symbols provided to getCryptoSnapshots, returning empty response', { type: 'warn' });
+            return { snapshots: {} };
+        }
+        return this.makeRequest('/crypto/us/snapshots', 'GET', { symbols: symbols.join(',') }, 'v1beta3');
+    }
+    /**
+     * Get the latest orderbook for requested crypto symbols
+     * @param symbols Array of crypto symbols to query
+     * @returns Latest orderbook data for each symbol
+     */
+    async getCryptoLatestOrderbooks(symbols) {
+        if (!symbols || symbols.length === 0) {
+            log('No symbols provided to getCryptoLatestOrderbooks, returning empty response', { type: 'warn' });
+            return { orderbooks: {} };
+        }
+        return this.makeRequest('/crypto/us/latest/orderbooks', 'GET', { symbols: symbols.join(',') }, 'v1beta3');
+    }
+    /**
+     * Analyzes an array of crypto bars and returns a summary string
+     * @param bars Array of crypto bars to analyze
+     * @returns A string summarizing the crypto price data
+     */
+    static analyzeCryptoBars(bars) {
+        if (!bars || bars.length === 0) {
+            return 'No crypto price data available';
+        }
+        const firstBar = bars[0];
+        const lastBar = bars[bars.length - 1];
+        const priceChange = lastBar.c - firstBar.o;
+        const percentChange = (priceChange / firstBar.o) * 100;
+        const volumeChange = lastBar.v - firstBar.v;
+        const percentVolumeChange = firstBar.v > 0 ? (volumeChange / firstBar.v) * 100 : 0;
+        const high = Math.max(...bars.map((bar) => bar.h));
+        const low = Math.min(...bars.map((bar) => bar.l));
+        const totalVolume = bars.reduce((sum, bar) => sum + bar.v, 0);
+        const avgVolume = totalVolume / bars.length;
+        return (`Crypto Price: $${firstBar.o.toFixed(6)} -> $${lastBar.c.toFixed(6)} (${percentChange.toFixed(2)}%), ` +
+            `Volume: ${firstBar.v.toLocaleString()} -> ${lastBar.v.toLocaleString()} (${percentVolumeChange.toFixed(2)}%), ` +
+            `High: $${high.toFixed(6)}, Low: $${low.toFixed(6)}, ` +
+            `Avg Volume: ${avgVolume.toLocaleString()}`);
+    }
 }
 // Export the singleton instance
-AlpacaMarketDataAPI.getInstance();
-
-const disco = {
-    time: {
-        getStartAndEndDates: getStartAndEndDates,
-        getMarketOpenClose: getMarketOpenClose,
-        getLastFullTradingDate: getLastFullTradingDate,
-        getNextMarketDay: getNextMarketDay,
-        getPreviousMarketDay: getPreviousMarketDay,
-        getMarketTimePeriod: getMarketTimePeriod,
-        getMarketStatus: getMarketStatus,
-        getNYTimeZone: getNYTimeZone,
-        getTradingDate: getTradingDate,
-        getTradingStartAndEndDates: getTradingStartAndEndDates,
-        isMarketDay: isMarketDay,
-        isWithinMarketHours: isWithinMarketHours,
-        countTradingDays: countTradingDays,
-        MARKET_TIMES: MARKET_TIMES,
-    }};
+const marketDataAPI = AlpacaMarketDataAPI.getInstance();
+
+var alpacaMarketDataApi = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AlpacaMarketDataAPI: AlpacaMarketDataAPI,
+    marketDataAPI: marketDataAPI
+});
 
 // Test file for context functionality
-// Test getMarketStatus with various scenarios
-function testGetMarketStatus() {
-    const testCases = [
-        {
-            label: 'Weekend (Saturday, market closed)',
-            date: '2025-07-12T12:00:00-04:00',
-            expected: {
-                status: 'closed',
-                nextStatus: 'extended hours',
-                marketPeriod: 'closed',
-            },
-        },
-        // do before preMarket
-        {
-            label: 'Before pre-market (market closed)',
-            date: '2025-07-10T03:00:00-04:00',
-            expected: {
-                status: 'closed',
-                nextStatus: 'extended hours',
-                marketPeriod: 'closed',
-            },
-        },
-        {
-            label: 'Pre-market (before open)',
-            date: '2025-07-10T08:00:00-04:00', // 8am EDT
-            expected: {
-                status: 'extended hours',
-                nextStatus: 'open',
-                marketPeriod: 'preMarket',
-            },
-        },
-        {
-            label: 'Extended hours (pre-market)',
-            date: '2025-07-10T05:00:00-04:00',
-            expected: {
-                status: 'extended hours',
-                nextStatus: 'open',
-                marketPeriod: 'preMarket',
-            },
-        },
-        {
-            label: 'Market open (regular)',
-            date: '2025-07-10T10:00:00-04:00',
-            expected: {
-                status: 'open',
-                nextStatus: 'extended hours',
-                marketPeriod: 'regularMarket',
-            },
-        },
-        {
-            label: 'Market open (early market)',
-            date: '2025-07-03T09:45:00-04:00', // Early close day
-            expected: {
-                status: 'open',
-                nextStatus: 'extended hours',
-                marketPeriod: 'earlyMarket',
-            },
-        },
-        {
-            label: 'After market close (extended hours)',
-            date: '2025-07-10T17:00:00-04:00',
-            expected: {
-                status: 'extended hours',
-                nextStatus: 'closed',
-                marketPeriod: 'afterMarket',
-            },
-        },
-        {
-            label: 'After extended hours (market closed)',
-            date: '2025-07-10T21:00:00-04:00',
-            expected: {
-                status: 'closed',
-                nextStatus: 'extended hours',
-                marketPeriod: 'closed',
-            },
-        },
-    ];
-    for (const { label, date, expected } of testCases) {
-        const result = disco.time.getMarketStatus({ date: new Date(date) });
-        const pass = result.status === expected.status &&
-            result.nextStatus === expected.nextStatus &&
-            result.marketPeriod === expected.marketPeriod;
-        console.log(`\nTest: ${label}`);
-        console.log(`  Input date: ${date}`);
-        console.log(`  Status: ${result.status} ${pass ? '✓' : `✗ (expected ${expected.status})`}`);
-        console.log(`  NextStatus: ${result.nextStatus} ${pass ? '✓' : `✗ (expected ${expected.nextStatus})`}`);
-        console.log(`  MarketPeriod: ${result.marketPeriod} ${pass ? '✓' : `✗ (expected ${expected.marketPeriod})`}`);
-        const nextStatusTimeDifferenceMs = result.nextStatusTimeDifference;
-        // convert that to a string in the form 'xxh xxm'
-        const nextStatusTimeDifferenceStr = `${Math.floor(nextStatusTimeDifferenceMs / (1000 * 60 * 60))}h ${Math.floor((nextStatusTimeDifferenceMs % (1000 * 60 * 60)) / (1000 * 60))}m`;
-        console.log(`  Next market status: ${result.nextStatus} at ${result.nextStatusTime.toLocaleString('en-US', { timeZone: 'America/New_York' })} in ${nextStatusTimeDifferenceStr}`);
-        if (!pass) {
-            console.error(`  FAILED: Expected status=${expected.status}, nextStatus=${expected.nextStatus}, marketPeriod=${expected.marketPeriod}, got status=${result.status}, nextStatus=${result.nextStatus}, marketPeriod=${result.marketPeriod}`);
+//testGetPortfolioDailyHistory();
+//testOpenRouter();
+//testGetMarketStatus();
+// ===== CRYPTO API TESTS =====
+async function testCryptoMarketData() {
+    console.log('\n--- Testing Crypto Market Data API ---');
+    const log = (message, options = { type: 'info' }) => {
+        log$1(message, { ...options, source: 'Test' });
+    };
+    if (!process.env.ALPACA_API_KEY || !process.env.ALPACA_SECRET_KEY) {
+        console.log('Skipping Alpaca crypto tests: Missing environment variables (ALPACA_API_KEY, ALPACA_SECRET_KEY)');
+        return;
+    }
+    try {
+        const { marketDataAPI } = await Promise.resolve().then(function () { return alpacaMarketDataApi; });
+        const { ALPACA_CRYPTO_PAIRS } = await import('./alpaca-crypto-pairs-DMOvRyzw.js');
+        // Test symbols - using popular crypto pairs
+        const testSymbols = ['BTC/USD', 'ETH/USD', 'DOGE/USD'];
+        log(`Testing with crypto symbols: ${testSymbols.join(', ')}`);
+        // 1. Test latest crypto bars
+        console.log('\n[Crypto] Testing latest bars...');
+        try {
+            const latestBars = await marketDataAPI.getCryptoLatestBars(testSymbols);
+            console.log(`✓ Retrieved latest bars for ${Object.keys(latestBars.bars).length} symbols`);
+            // Show sample data for first symbol
+            const firstSymbol = Object.keys(latestBars.bars)[0];
+            if (firstSymbol) {
+                const bar = latestBars.bars[firstSymbol];
+                console.log(`  ${firstSymbol}: Open=$${bar.o.toFixed(4)}, Close=$${bar.c.toFixed(4)}, Volume=${bar.v.toLocaleString()}`);
+            }
+        }
+        catch (error) {
+            console.error('✗ Latest bars test failed:', error);
+        }
+        // 2. Test latest crypto quotes
+        console.log('\n[Crypto] Testing latest quotes...');
+        try {
+            const latestQuotes = await marketDataAPI.getCryptoLatestQuotes(testSymbols);
+            console.log(`✓ Retrieved latest quotes for ${Object.keys(latestQuotes.quotes).length} symbols`);
+            // Show sample data for first symbol
+            const firstSymbol = Object.keys(latestQuotes.quotes)[0];
+            if (firstSymbol) {
+                const quote = latestQuotes.quotes[firstSymbol];
+                console.log(`  ${firstSymbol}: Bid=$${quote.bp.toFixed(4)}, Ask=$${quote.ap.toFixed(4)}, Spread=$${(quote.ap - quote.bp).toFixed(4)}`);
+            }
+        }
+        catch (error) {
+            console.error('✗ Latest quotes test failed:', error);
+        }
+        // 3. Test latest crypto trades
+        console.log('\n[Crypto] Testing latest trades...');
+        try {
+            const latestTrades = await marketDataAPI.getCryptoLatestTrades(testSymbols);
+            console.log(`✓ Retrieved latest trades for ${Object.keys(latestTrades.trades).length} symbols`);
+            // Show sample data for first symbol
+            const firstSymbol = Object.keys(latestTrades.trades)[0];
+            if (firstSymbol) {
+                const trade = latestTrades.trades[firstSymbol];
+                console.log(`  ${firstSymbol}: Price=$${trade.p.toFixed(4)}, Size=${trade.s.toLocaleString()}, Taker=${trade.tks}`);
+            }
+        }
+        catch (error) {
+            console.error('✗ Latest trades test failed:', error);
+        }
+        // 4. Test crypto snapshots
+        console.log('\n[Crypto] Testing snapshots...');
+        try {
+            const snapshots = await marketDataAPI.getCryptoSnapshots(testSymbols);
+            console.log(`✓ Retrieved snapshots for ${Object.keys(snapshots.snapshots).length} symbols`);
+            // Show sample data for first symbol
+            const firstSymbol = Object.keys(snapshots.snapshots)[0];
+            if (firstSymbol) {
+                const snapshot = snapshots.snapshots[firstSymbol];
+                console.log(`  ${firstSymbol} snapshot:`);
+                if (snapshot.latestTrade) {
+                    console.log(`    Latest trade: $${snapshot.latestTrade.p.toFixed(4)}`);
+                }
+                if (snapshot.latestQuote) {
+                    console.log(`    Latest quote: $${snapshot.latestQuote.bp.toFixed(4)} x $${snapshot.latestQuote.ap.toFixed(4)}`);
+                }
+                if (snapshot.dailyBar) {
+                    console.log(`    Daily bar: Open=$${snapshot.dailyBar.o.toFixed(4)}, Close=$${snapshot.dailyBar.c.toFixed(4)}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error('✗ Snapshots test failed:', error);
+        }
+        // 5. Test crypto orderbooks
+        console.log('\n[Crypto] Testing orderbooks...');
+        try {
+            const orderbooks = await marketDataAPI.getCryptoLatestOrderbooks(testSymbols);
+            console.log(`✓ Retrieved orderbooks for ${Object.keys(orderbooks.orderbooks).length} symbols`);
+            // Show sample data for first symbol
+            const firstSymbol = Object.keys(orderbooks.orderbooks)[0];
+            if (firstSymbol) {
+                const orderbook = orderbooks.orderbooks[firstSymbol];
+                console.log(`  ${firstSymbol} orderbook:`);
+                console.log(`    Best bid: $${orderbook.b[0]?.p.toFixed(4)} (size: ${orderbook.b[0]?.s.toLocaleString()})`);
+                console.log(`    Best ask: $${orderbook.a[0]?.p.toFixed(4)} (size: ${orderbook.a[0]?.s.toLocaleString()})`);
+                console.log(`    Bid depth: ${orderbook.b.length} levels, Ask depth: ${orderbook.a.length} levels`);
+            }
+        }
+        catch (error) {
+            console.error('✗ Orderbooks test failed:', error);
+        }
+        // 6. Test historical crypto bars (small sample)
+        console.log('\n[Crypto] Testing historical bars...');
+        try {
+            const endDate = new Date();
+            const startDate = new Date(endDate.getTime() - 24 * 60 * 60 * 1000); // 24 hours ago
+            const historicalBars = await marketDataAPI.getCryptoHistoricalBars({
+                symbols: ['BTC/USD'], // Just test one symbol to avoid too much data
+                timeframe: '1Hour',
+                start: startDate.toISOString(),
+                end: endDate.toISOString(),
+                limit: 10
+            });
+            console.log(`✓ Retrieved historical bars for ${Object.keys(historicalBars.bars).length} symbols`);
+            const btcBars = historicalBars.bars['BTC/USD'];
+            if (btcBars && btcBars.length > 0) {
+                console.log(`  BTC/USD: ${btcBars.length} bars retrieved`);
+                const { AlpacaMarketDataAPI } = await Promise.resolve().then(function () { return alpacaMarketDataApi; });
+                const analysis = AlpacaMarketDataAPI.analyzeCryptoBars(btcBars);
+                console.log(`  Analysis: ${analysis}`);
+            }
+        }
+        catch (error) {
+            console.error('✗ Historical bars test failed:', error);
+        }
+        // 7. Test historical crypto quotes (small sample)
+        console.log('\n[Crypto] Testing historical quotes...');
+        try {
+            const endDate = new Date();
+            const startDate = new Date(endDate.getTime() - 2 * 60 * 60 * 1000); // 2 hours ago
+            const historicalQuotes = await marketDataAPI.getCryptoHistoricalQuotes({
+                symbols: ['ETH/USD'], // Just test one symbol
+                start: startDate.toISOString(),
+                end: endDate.toISOString(),
+                limit: 10
+            });
+            console.log(`✓ Retrieved historical quotes for ${Object.keys(historicalQuotes.quotes).length} symbols`);
+            const ethQuotes = historicalQuotes.quotes['ETH/USD'];
+            if (ethQuotes && ethQuotes.length > 0) {
+                console.log(`  ETH/USD: ${ethQuotes.length} quotes retrieved`);
+                const firstQuote = ethQuotes[0];
+                const lastQuote = ethQuotes[ethQuotes.length - 1];
+                console.log(`  First quote: Bid=$${firstQuote.bp.toFixed(4)}, Ask=$${firstQuote.ap.toFixed(4)}`);
+                console.log(`  Last quote: Bid=$${lastQuote.bp.toFixed(4)}, Ask=$${lastQuote.ap.toFixed(4)}`);
+            }
+        }
+        catch (error) {
+            console.error('✗ Historical quotes test failed:', error);
+        }
+        // 8. Test historical crypto trades (small sample)
+        console.log('\n[Crypto] Testing historical trades...');
+        try {
+            const endDate = new Date();
+            const startDate = new Date(endDate.getTime() - 2 * 60 * 60 * 1000); // 2 hours ago
+            const historicalTrades = await marketDataAPI.getCryptoHistoricalTrades({
+                symbols: ['DOGE/USD'], // Just test one symbol
+                start: startDate.toISOString(),
+                end: endDate.toISOString(),
+                limit: 10
+            });
+            console.log(`✓ Retrieved historical trades for ${Object.keys(historicalTrades.trades).length} symbols`);
+            const dogeTrades = historicalTrades.trades['DOGE/USD'];
+            if (dogeTrades && dogeTrades.length > 0) {
+                console.log(`  DOGE/USD: ${dogeTrades.length} trades retrieved`);
+                const totalVolume = dogeTrades.reduce((sum, trade) => sum + trade.s, 0);
+                const avgPrice = dogeTrades.reduce((sum, trade) => sum + trade.p, 0) / dogeTrades.length;
+                console.log(`  Total volume: ${totalVolume.toLocaleString()}, Avg price: $${avgPrice.toFixed(6)}`);
+            }
+        }
+        catch (error) {
+            console.error('✗ Historical trades test failed:', error);
+        }
+        // 9. Test with available crypto pairs from our types
+        console.log('\n[Crypto] Testing with available crypto pairs...');
+        try {
+            const availablePairs = ALPACA_CRYPTO_PAIRS.slice(0, 5).map(pair => pair.symbol); // Test first 5 pairs
+            console.log(`Testing with pairs: ${availablePairs.join(', ')}`);
+            const pairsBars = await marketDataAPI.getCryptoLatestBars(availablePairs);
+            console.log(`✓ Retrieved latest bars for ${Object.keys(pairsBars.bars).length} pairs from ALPACA_CRYPTO_PAIRS`);
+            // Show info about each pair
+            availablePairs.forEach(symbol => {
+                const pair = ALPACA_CRYPTO_PAIRS.find(p => p.symbol === symbol);
+                const bar = pairsBars.bars[symbol];
+                if (pair && bar) {
+                    console.log(`  ${pair.name}: $${bar.c.toFixed(6)} (min order: ${pair.min_order_size})`);
+                }
+            });
+        }
+        catch (error) {
+            console.error('✗ Available crypto pairs test failed:', error);
+        }
+        console.log('\n✓ All crypto market data tests completed!');
+    }
+    catch (error) {
+        console.error('✗ Crypto tests setup failed:', error);
+        if (error instanceof Error) {
+            console.error('Error message:', error.message);
         }
     }
 }
-//testGetPortfolioDailyHistory();
-//testOpenRouter();
-testGetMarketStatus();
+// Run crypto tests
+testCryptoMarketData();
 //# sourceMappingURL=test.js.map