@discomedia/utils 1.0.32 → 1.0.34

package/dist/index-frontend.mjs

@@ -13862,6 +13862,21 @@ function getLastFullTradingDateImpl(currentDate = new Date()) {
 function getLastFullTradingDate(currentDate = new Date()) {
     return getLastFullTradingDateImpl(currentDate);
 }
+/**
+ * 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')}`;
+}
 
 const log = (message, options = { type: 'info' }) => {
     log$1(message, { ...options, source: 'AlpacaMarketDataAPI' });
@@ -13880,6 +13895,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;
@@ -13922,6 +13938,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,
@@ -14059,7 +14076,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) {
@@ -14767,6 +14786,253 @@ 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
 const marketDataAPI = AlpacaMarketDataAPI.getInstance();
@@ -15527,9 +15793,18 @@ class AlpacaTradingAPI {
         // Get the most recent hourly data point
         const mostRecentHourly = recentHourlyData[recentHourlyData.length - 1];
         const mostRecentIndex = mostRecentHourly.index;
-        // Calculate the timestamp for the new daily entry (most recent day + 1 day worth of seconds)
-        const oneDayInSeconds = 24 * 60 * 60;
-        const newDailyTimestamp = mostRecentHourly.timestamp + oneDayInSeconds;
+        // Calculate the timestamp for the new daily entry.
+        // Alpaca's daily history timestamps are at 00:00:00Z for the calendar day
+        // following the NY trading date. Derive the trading date in NY time from the
+        // most recent intraday timestamp, then set the new daily timestamp to
+        // midnight UTC of the next calendar day.
+        const mostRecentMs = mostRecentHourly.timestamp * 1000; // hourly timestamps are seconds
+        const tradingDateStr = getTradingDate(new Date(mostRecentMs)); // e.g., '2025-09-05' (NY trading date)
+        const [yearStr, monthStr, dayStr] = tradingDateStr.split('-');
+        const year = Number(yearStr);
+        const month = Number(monthStr); // 1-based
+        const day = Number(dayStr);
+        const newDailyTimestamp = Math.floor(Date.UTC(year, month - 1, day + 1, 0, 0, 0, 0) / 1000);
         // Create a new daily history entry with the most recent hourly values
         const updatedDailyHistory = {
             ...dailyHistory,