prab-cli 1.2.6 → 1.2.7

package/dist/lib/crypto/data-fetcher.js

@@ -60,42 +60,150 @@ const SYMBOL_MAP = {
     wif: "WIFUSDT",
 };
 const BINANCE_API_BASE = "https://api.binance.com/api/v3";
+const BYBIT_API_BASE = "https://api.bybit.com/v5/market";
+const CRYPTOCOMPARE_API_BASE = "https://min-api.cryptocompare.com/data";
+// Map Binance intervals to Bybit intervals
+const BYBIT_INTERVAL_MAP = {
+    "1m": "1",
+    "5m": "5",
+    "15m": "15",
+    "1h": "60",
+    "4h": "240",
+    "1d": "D",
+    "1w": "W",
+};
+// Map intervals to CryptoCompare endpoints and params
+const CRYPTOCOMPARE_INTERVAL_MAP = {
+    "1m": { endpoint: "histominute", aggregate: 1 },
+    "5m": { endpoint: "histominute", aggregate: 5 },
+    "15m": { endpoint: "histominute", aggregate: 15 },
+    "1h": { endpoint: "histohour", aggregate: 1 },
+    "4h": { endpoint: "histohour", aggregate: 4 },
+    "1d": { endpoint: "histoday", aggregate: 1 },
+    "1w": { endpoint: "histoday", aggregate: 7 },
+};
 // Cache for valid Binance symbols
 let cachedSymbols = null;
 let cacheTimestamp = 0;
 const CACHE_DURATION = 1000 * 60 * 60; // 1 hour cache
 /**
- * Fetch all valid USDT trading pairs from Binance
+ * Fetch all valid USDT trading pairs from Bybit (fallback)
  */
-async function fetchAllSymbols() {
-    // Return cached symbols if still valid
-    if (cachedSymbols && Date.now() - cacheTimestamp < CACHE_DURATION) {
-        return cachedSymbols;
-    }
+async function fetchAllSymbolsFromBybit() {
     try {
-        const response = await fetch(`${BINANCE_API_BASE}/exchangeInfo`);
+        const response = await fetch(`${BYBIT_API_BASE}/instruments-info?category=spot`);
         if (!response.ok) {
-            throw new Error("Failed to fetch exchange info");
+            throw new Error("Failed to fetch exchange info from Bybit");
         }
         const data = await response.json();
         const symbols = new Set();
-        for (const symbol of data.symbols) {
-            // Only include USDT pairs that are trading
-            if (symbol.status === "TRADING" && symbol.quoteAsset === "USDT") {
-                symbols.add(symbol.symbol);
-                // Also add the base asset for easy lookup
-                symbols.add(symbol.baseAsset.toLowerCase());
+        if (data.retCode === 0 && data.result.list) {
+            for (const instrument of data.result.list) {
+                // Only include USDT pairs that are trading
+                if (instrument.status === "Trading" && instrument.quoteCoin === "USDT") {
+                    symbols.add(instrument.symbol);
+                    // Also add the base asset for easy lookup
+                    symbols.add(instrument.baseCoin.toLowerCase());
+                }
             }
         }
-        cachedSymbols = symbols;
-        cacheTimestamp = Date.now();
         return symbols;
     }
-    catch (error) {
-        // Return empty set on error, will fall back to direct API check
+    catch {
         return new Set();
     }
 }
+/**
+ * Get common crypto symbols as fallback (when all APIs are blocked)
+ */
+function getCommonSymbols() {
+    const common = [
+        "BTC",
+        "ETH",
+        "BNB",
+        "XRP",
+        "SOL",
+        "ADA",
+        "DOGE",
+        "DOT",
+        "MATIC",
+        "LTC",
+        "AVAX",
+        "LINK",
+        "ATOM",
+        "UNI",
+        "XLM",
+        "ALGO",
+        "NEAR",
+        "APT",
+        "ARB",
+        "OP",
+        "SUI",
+        "PEPE",
+        "SHIB",
+        "WIF",
+        "TRX",
+        "ETC",
+        "FIL",
+        "HBAR",
+        "VET",
+        "ICP",
+    ];
+    const symbols = new Set();
+    for (const sym of common) {
+        symbols.add(`${sym}USDT`);
+        symbols.add(sym.toLowerCase());
+    }
+    return symbols;
+}
+/**
+ * Fetch all valid USDT trading pairs (tries Binance -> Bybit -> fallback to common)
+ */
+async function fetchAllSymbols() {
+    // Return cached symbols if still valid
+    if (cachedSymbols && Date.now() - cacheTimestamp < CACHE_DURATION) {
+        return cachedSymbols;
+    }
+    // Try Binance first
+    try {
+        const response = await fetch(`${BINANCE_API_BASE}/exchangeInfo`);
+        if (response.ok) {
+            const data = await response.json();
+            const symbols = new Set();
+            for (const symbol of data.symbols) {
+                // Only include USDT pairs that are trading
+                if (symbol.status === "TRADING" && symbol.quoteAsset === "USDT") {
+                    symbols.add(symbol.symbol);
+                    // Also add the base asset for easy lookup
+                    symbols.add(symbol.baseAsset.toLowerCase());
+                }
+            }
+            cachedSymbols = symbols;
+            cacheTimestamp = Date.now();
+            return symbols;
+        }
+    }
+    catch {
+        // Continue to fallback
+    }
+    // Try Bybit as fallback
+    try {
+        const symbols = await fetchAllSymbolsFromBybit();
+        if (symbols.size > 0) {
+            cachedSymbols = symbols;
+            cacheTimestamp = Date.now();
+            return symbols;
+        }
+    }
+    catch {
+        // Continue to fallback
+    }
+    // Use common symbols as final fallback
+    const symbols = getCommonSymbols();
+    cachedSymbols = symbols;
+    cacheTimestamp = Date.now();
+    return symbols;
+}
 /**
  * Get similar symbols for suggestions
  */
@@ -142,49 +250,233 @@ function normalizeSymbol(input) {
     return lower.toUpperCase() + "USDT";
 }
 /**
- * Fetch OHLCV candle data from Binance
+ * Fetch OHLCV candle data from Bybit (fallback)
  */
-async function fetchOHLCV(symbol, interval = "1h", limit = 100) {
+async function fetchOHLCVFromBybit(symbol, interval = "1h", limit = 100) {
     const normalizedSymbol = normalizeSymbol(symbol);
-    const url = `${BINANCE_API_BASE}/klines?symbol=${normalizedSymbol}&interval=${interval}&limit=${limit}`;
+    const bybitInterval = BYBIT_INTERVAL_MAP[interval];
+    const url = `${BYBIT_API_BASE}/kline?category=spot&symbol=${normalizedSymbol}&interval=${bybitInterval}&limit=${limit}`;
     const response = await fetch(url);
     if (!response.ok) {
         const error = await response.text();
         throw new Error(`Failed to fetch data for ${normalizedSymbol}: ${error}`);
     }
     const data = await response.json();
-    // Binance klines format:
-    // [0] Open time, [1] Open, [2] High, [3] Low, [4] Close, [5] Volume, ...
-    return data.map((candle) => ({
-        timestamp: candle[0],
+    if (data.retCode !== 0) {
+        throw new Error(`Bybit API error: ${data.retMsg}`);
+    }
+    // Bybit klines are in reverse order (newest first), so we reverse them
+    // Format: [startTime, openPrice, highPrice, lowPrice, closePrice, volume, turnover]
+    return data.result.list
+        .map((candle) => ({
+        timestamp: parseInt(candle[0]),
         open: parseFloat(candle[1]),
         high: parseFloat(candle[2]),
         low: parseFloat(candle[3]),
         close: parseFloat(candle[4]),
         volume: parseFloat(candle[5]),
-    }));
+    }))
+        .reverse();
 }
 /**
- * Fetch 24h ticker data for price change info
+ * Fetch 24h ticker data from Bybit (fallback)
  */
-async function fetch24hTicker(symbol) {
+async function fetch24hTickerFromBybit(symbol) {
     const normalizedSymbol = normalizeSymbol(symbol);
-    const url = `${BINANCE_API_BASE}/ticker/24hr?symbol=${normalizedSymbol}`;
+    const url = `${BYBIT_API_BASE}/tickers?category=spot&symbol=${normalizedSymbol}`;
     const response = await fetch(url);
     if (!response.ok) {
         const error = await response.text();
         throw new Error(`Failed to fetch ticker for ${normalizedSymbol}: ${error}`);
     }
     const data = await response.json();
+    if (data.retCode !== 0 || !data.result.list.length) {
+        throw new Error(`Bybit API error: ${data.retMsg || "Symbol not found"}`);
+    }
+    const ticker = data.result.list[0];
+    const price = parseFloat(ticker.lastPrice);
+    const prevPrice = parseFloat(ticker.prevPrice24h);
+    const priceChange = price - prevPrice;
+    const priceChangePercent = parseFloat(ticker.price24hPcnt) * 100;
+    return {
+        price,
+        priceChange,
+        priceChangePercent,
+        high24h: parseFloat(ticker.highPrice24h),
+        low24h: parseFloat(ticker.lowPrice24h),
+        volume24h: parseFloat(ticker.volume24h),
+    };
+}
+/**
+ * Check if error is due to geo-restriction or CloudFront block
+ */
+function isGeoRestricted(error) {
+    return (error.includes("restricted location") ||
+        error.includes("Service unavailable") ||
+        error.includes("CloudFront") ||
+        error.includes("403") ||
+        error.includes("block access from your country"));
+}
+/**
+ * Extract base symbol from normalized symbol (e.g., BTCUSDT -> BTC)
+ */
+function getBaseSymbol(normalizedSymbol) {
+    if (normalizedSymbol.endsWith("USDT")) {
+        return normalizedSymbol.slice(0, -4);
+    }
+    if (normalizedSymbol.endsWith("USD")) {
+        return normalizedSymbol.slice(0, -3);
+    }
+    return normalizedSymbol;
+}
+/**
+ * Fetch OHLCV candle data from CryptoCompare (globally accessible, no geo-restrictions)
+ */
+async function fetchOHLCVFromCryptoCompare(symbol, interval = "1h", limit = 100) {
+    const normalizedSymbol = normalizeSymbol(symbol);
+    const baseSymbol = getBaseSymbol(normalizedSymbol);
+    const { endpoint, aggregate } = CRYPTOCOMPARE_INTERVAL_MAP[interval];
+    const url = `${CRYPTOCOMPARE_API_BASE}/v2/${endpoint}?fsym=${baseSymbol}&tsym=USDT&limit=${limit}&aggregate=${aggregate}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`CryptoCompare error for ${baseSymbol}: ${error}`);
+    }
+    const data = await response.json();
+    if (data.Response === "Error") {
+        throw new Error(`CryptoCompare error: ${data.Message}`);
+    }
+    // CryptoCompare format: { time, open, high, low, close, volumefrom, volumeto }
+    return data.Data.Data.map((candle) => ({
+        timestamp: candle.time * 1000, // Convert to milliseconds
+        open: candle.open,
+        high: candle.high,
+        low: candle.low,
+        close: candle.close,
+        volume: candle.volumefrom,
+    }));
+}
+/**
+ * Fetch 24h ticker data from CryptoCompare (globally accessible)
+ */
+async function fetch24hTickerFromCryptoCompare(symbol) {
+    const normalizedSymbol = normalizeSymbol(symbol);
+    const baseSymbol = getBaseSymbol(normalizedSymbol);
+    // Fetch current price and 24h data
+    const [priceResponse, dayResponse] = await Promise.all([
+        fetch(`${CRYPTOCOMPARE_API_BASE}/price?fsym=${baseSymbol}&tsyms=USDT`),
+        fetch(`${CRYPTOCOMPARE_API_BASE}/v2/histoday?fsym=${baseSymbol}&tsym=USDT&limit=1`),
+    ]);
+    if (!priceResponse.ok || !dayResponse.ok) {
+        throw new Error(`CryptoCompare error fetching ticker for ${baseSymbol}`);
+    }
+    const priceData = await priceResponse.json();
+    const dayData = await dayResponse.json();
+    if (priceData.Response === "Error" || dayData.Response === "Error") {
+        throw new Error(`CryptoCompare error: Symbol ${baseSymbol} not found`);
+    }
+    const currentPrice = priceData.USDT;
+    const dayCandles = dayData.Data.Data;
+    // Get yesterday's data for 24h change calculation
+    const yesterday = dayCandles[0];
+    const today = dayCandles[1] || yesterday;
+    const priceChange = currentPrice - yesterday.close;
+    const priceChangePercent = (priceChange / yesterday.close) * 100;
     return {
-        price: parseFloat(data.lastPrice),
-        priceChange: parseFloat(data.priceChange),
-        priceChangePercent: parseFloat(data.priceChangePercent),
-        high24h: parseFloat(data.highPrice),
-        low24h: parseFloat(data.lowPrice),
-        volume24h: parseFloat(data.volume),
+        price: currentPrice,
+        priceChange,
+        priceChangePercent,
+        high24h: today.high,
+        low24h: today.low,
+        volume24h: today.volumefrom,
     };
 }
+/**
+ * Fetch OHLCV candle data (tries Binance -> Bybit -> CryptoCompare)
+ */
+async function fetchOHLCV(symbol, interval = "1h", limit = 100) {
+    const normalizedSymbol = normalizeSymbol(symbol);
+    const errors = [];
+    // Try Binance first
+    try {
+        const url = `${BINANCE_API_BASE}/klines?symbol=${normalizedSymbol}&interval=${interval}&limit=${limit}`;
+        const response = await fetch(url);
+        if (response.ok) {
+            const data = await response.json();
+            // Binance klines format:
+            // [0] Open time, [1] Open, [2] High, [3] Low, [4] Close, [5] Volume, ...
+            return data.map((candle) => ({
+                timestamp: candle[0],
+                open: parseFloat(candle[1]),
+                high: parseFloat(candle[2]),
+                low: parseFloat(candle[3]),
+                close: parseFloat(candle[4]),
+                volume: parseFloat(candle[5]),
+            }));
+        }
+        errors.push(`Binance: ${response.status}`);
+    }
+    catch (e) {
+        errors.push(`Binance: ${e.message}`);
+    }
+    // Try Bybit as fallback
+    try {
+        return await fetchOHLCVFromBybit(symbol, interval, limit);
+    }
+    catch (e) {
+        errors.push(`Bybit: ${e.message}`);
+    }
+    // Try CryptoCompare as final fallback (globally accessible)
+    try {
+        return await fetchOHLCVFromCryptoCompare(symbol, interval, limit);
+    }
+    catch (e) {
+        errors.push(`CryptoCompare: ${e.message}`);
+    }
+    throw new Error(`Failed to fetch data for ${normalizedSymbol}. Tried all providers: ${errors.join("; ")}`);
+}
+/**
+ * Fetch 24h ticker data for price change info (tries Binance -> Bybit -> CryptoCompare)
+ */
+async function fetch24hTicker(symbol) {
+    const normalizedSymbol = normalizeSymbol(symbol);
+    const errors = [];
+    // Try Binance first
+    try {
+        const url = `${BINANCE_API_BASE}/ticker/24hr?symbol=${normalizedSymbol}`;
+        const response = await fetch(url);
+        if (response.ok) {
+            const data = await response.json();
+            return {
+                price: parseFloat(data.lastPrice),
+                priceChange: parseFloat(data.priceChange),
+                priceChangePercent: parseFloat(data.priceChangePercent),
+                high24h: parseFloat(data.highPrice),
+                low24h: parseFloat(data.lowPrice),
+                volume24h: parseFloat(data.volume),
+            };
+        }
+        errors.push(`Binance: ${response.status}`);
+    }
+    catch (e) {
+        errors.push(`Binance: ${e.message}`);
+    }
+    // Try Bybit as fallback
+    try {
+        return await fetch24hTickerFromBybit(symbol);
+    }
+    catch (e) {
+        errors.push(`Bybit: ${e.message}`);
+    }
+    // Try CryptoCompare as final fallback (globally accessible)
+    try {
+        return await fetch24hTickerFromCryptoCompare(symbol);
+    }
+    catch (e) {
+        errors.push(`CryptoCompare: ${e.message}`);
+    }
+    throw new Error(`Failed to fetch ticker for ${normalizedSymbol}. Tried all providers: ${errors.join("; ")}`);
+}
 /**
  * Fetch complete crypto data for analysis
  */
@@ -211,20 +503,24 @@ function getSupportedSymbols() {
     return [...new Set(Object.keys(SYMBOL_MAP))];
 }
 /**
- * Check if a symbol is valid/supported
+ * Check if a symbol is valid/supported by trying to fetch its price
  */
 async function isValidSymbol(symbol) {
     try {
         const normalizedSymbol = normalizeSymbol(symbol);
-        // First check cache
+        // First check our symbol cache
         const symbols = await fetchAllSymbols();
-        if (symbols.has(normalizedSymbol)) {
+        if (symbols.has(normalizedSymbol) || symbols.has(normalizedSymbol.toLowerCase())) {
             return true;
         }
-        // Fall back to direct API check
-        const url = `${BINANCE_API_BASE}/ticker/price?symbol=${normalizedSymbol}`;
-        const response = await fetch(url);
-        return response.ok;
+        // Try to actually fetch the ticker to validate
+        try {
+            await fetch24hTicker(symbol);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
     catch {
         return false;
@@ -236,16 +532,12 @@ async function isValidSymbol(symbol) {
 async function validateSymbol(symbol) {
     const normalized = normalizeSymbol(symbol);
     try {
-        const url = `${BINANCE_API_BASE}/ticker/price?symbol=${normalized}`;
-        const response = await fetch(url);
-        if (response.ok) {
-            return { valid: true, normalized, suggestions: [] };
-        }
-        // If invalid, find similar symbols
-        const suggestions = await findSimilarSymbols(symbol, 5);
-        return { valid: false, normalized, suggestions };
+        // Try to fetch the ticker - this will try all providers
+        await fetch24hTicker(symbol);
+        return { valid: true, normalized, suggestions: [] };
     }
     catch {
+        // If invalid, find similar symbols from our cache
         const suggestions = await findSimilarSymbols(symbol, 5);
         return { valid: false, normalized, suggestions };
     }

package/dist/lib/crypto/index.js

@@ -4,7 +4,8 @@
  * Exports all crypto-related functionality
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.displayICTSignal = exports.generateICTSignal = exports.runICTStrategy = exports.displayOrderBlockSignal = exports.generateOrderBlockSignal = exports.runOrderBlockStrategy = exports.displayTradeSetup = exports.generateTradeSetup = exports.runStrategy = exports.displayNews = exports.fetchCryptoNews = exports.runCryptoNews = exports.displayScanResults = exports.runMarketScanner = exports.displayWhaleActivity = exports.runWhaleTracker = exports.displaySMCAnalysis = exports.runSMCAnalysis = exports.calculatePremiumDiscount = exports.findLiquidityZones = exports.findFairValueGaps = exports.findOrderBlocks = exports.findSwingPoints = exports.analyzeSMC = exports.analyzeTrend = exports.calculateSupportResistance = exports.analyzeVolume = exports.calculateATR = exports.calculateBollingerBands = exports.calculateMACD = exports.calculateRSI = exports.analyzeMarket = exports.displayComprehensiveAnalysis = exports.comprehensiveAnalysis = exports.fullSignal = exports.quickSignal = exports.displaySignal = exports.generateTradingSignal = exports.formatSignalSummary = exports.generateSignal = exports.calculateIndicators = exports.calculateAllEMAs = exports.calculateEMA = exports.isValidSymbol = exports.getSupportedSymbols = exports.normalizeSymbol = exports.fetch24hTicker = exports.fetchOHLCV = exports.fetchCryptoData = void 0;
+exports.runStrategy = exports.displayNews = exports.fetchCryptoNews = exports.runCryptoNews = exports.displayScanResults = exports.runMarketScanner = exports.displayWhaleActivity = exports.runWhaleTracker = exports.displaySMCAnalysis = exports.runSMCAnalysis = exports.calculatePremiumDiscount = exports.findLiquidityZones = exports.findFairValueGaps = exports.findOrderBlocks = exports.findSwingPoints = exports.analyzeSMC = exports.analyzeTrend = exports.calculateSupportResistance = exports.analyzeVolume = exports.calculateATR = exports.calculateBollingerBands = exports.calculateMACD = exports.calculateRSI = exports.analyzeMarket = exports.calculateConfluenceScore = exports.calculateRSIStrategy = exports.analyzeVolumeStrategy = exports.detectPullback = exports.detectKeyLevels = exports.detectCandlePattern = exports.generateStrategySignal = exports.displayStrategyResult = exports.runSmartStrategy = exports.displayComprehensiveAnalysis = exports.comprehensiveAnalysis = exports.fullSignal = exports.quickSignal = exports.displaySignal = exports.generateTradingSignal = exports.formatSignalSummary = exports.generateSignal = exports.calculateIndicators = exports.calculateAllEMAs = exports.calculateEMA = exports.isValidSymbol = exports.getSupportedSymbols = exports.normalizeSymbol = exports.fetch24hTicker = exports.fetchOHLCV = exports.fetchCryptoData = void 0;
+exports.displayICTSignal = exports.generateICTSignal = exports.runICTStrategy = exports.displayOrderBlockSignal = exports.generateOrderBlockSignal = exports.runOrderBlockStrategy = exports.displayTradeSetup = exports.generateTradeSetup = void 0;
 var data_fetcher_1 = require("./data-fetcher");
 Object.defineProperty(exports, "fetchCryptoData", { enumerable: true, get: function () { return data_fetcher_1.fetchCryptoData; } });
 Object.defineProperty(exports, "fetchOHLCV", { enumerable: true, get: function () { return data_fetcher_1.fetchOHLCV; } });
@@ -25,6 +26,16 @@ Object.defineProperty(exports, "quickSignal", { enumerable: true, get: function
 Object.defineProperty(exports, "fullSignal", { enumerable: true, get: function () { return signal_generator_1.fullSignal; } });
 Object.defineProperty(exports, "comprehensiveAnalysis", { enumerable: true, get: function () { return signal_generator_1.comprehensiveAnalysis; } });
 Object.defineProperty(exports, "displayComprehensiveAnalysis", { enumerable: true, get: function () { return signal_generator_1.displayComprehensiveAnalysis; } });
+Object.defineProperty(exports, "runSmartStrategy", { enumerable: true, get: function () { return signal_generator_1.runSmartStrategy; } });
+Object.defineProperty(exports, "displayStrategyResult", { enumerable: true, get: function () { return signal_generator_1.displayStrategyResult; } });
+var strategy_1 = require("./strategy");
+Object.defineProperty(exports, "generateStrategySignal", { enumerable: true, get: function () { return strategy_1.generateStrategySignal; } });
+Object.defineProperty(exports, "detectCandlePattern", { enumerable: true, get: function () { return strategy_1.detectCandlePattern; } });
+Object.defineProperty(exports, "detectKeyLevels", { enumerable: true, get: function () { return strategy_1.detectKeyLevels; } });
+Object.defineProperty(exports, "detectPullback", { enumerable: true, get: function () { return strategy_1.detectPullback; } });
+Object.defineProperty(exports, "analyzeVolumeStrategy", { enumerable: true, get: function () { return strategy_1.analyzeVolume; } });
+Object.defineProperty(exports, "calculateRSIStrategy", { enumerable: true, get: function () { return strategy_1.calculateRSI; } });
+Object.defineProperty(exports, "calculateConfluenceScore", { enumerable: true, get: function () { return strategy_1.calculateConfluenceScore; } });
 var market_analyzer_1 = require("./market-analyzer");
 Object.defineProperty(exports, "analyzeMarket", { enumerable: true, get: function () { return market_analyzer_1.analyzeMarket; } });
 var indicators_1 = require("./indicators");