@pioneer-platform/markets 8.12.0 → 8.13.0

package/lib/index.js

@@ -58,6 +58,11 @@ var TAG = " | market-module | ";
 var pioneer_discovery_1 = require("@pioneer-platform/pioneer-discovery");
 var caip_1 = require("@shapeshiftoss/caip");
 var Bottleneck = require('bottleneck');
+var token_bucket_manager_1 = require("./token-bucket-manager");
+var metrics_logger_1 = require("./metrics-logger");
+var refill_scheduler_1 = require("./refill-scheduler");
+var ccxt_pricing_1 = require("./ccxt-pricing");
+var api_metrics_reporter_1 = require("./api-metrics-reporter");
 var axiosLib = require('axios');
 var Axios = axiosLib.default || axiosLib;
 var https = require('https');
@@ -121,15 +126,44 @@ var unpriceableTokensCache = new Map();
 var UNPRICEABLE_TOKEN_PREFIX = 'unpriceable_token:';
 var UNPRICEABLE_TOKEN_TTL = 7 * 24 * 60 * 60; // 7 days
 var UNPRICEABLE_TOKEN_TTL_MS = UNPRICEABLE_TOKEN_TTL * 1000;
+// Redis keys for monitoring
+var REDIS_UNPRICEABLE_SET = 'markets:unpriceable_tokens';
+var REDIS_API_METRICS_KEY = 'markets:api_metrics';
+// CRITICAL: Major cryptocurrencies that should NEVER be marked as unpriceable
+// Even if all APIs fail, these are known legitimate assets - API failures are temporary
+var MAJOR_CRYPTO_WHITELIST = new Set([
+    'bip122:000000000019d6689c085ae165831e93/slip44:0', // Bitcoin
+    'eip155:1/slip44:60', // Ethereum
+    'eip155:56/slip44:60', // BNB Chain
+    'eip155:137/slip44:60', // Polygon
+    'eip155:42161/slip44:60', // Arbitrum
+    'eip155:10/slip44:60', // Optimism
+    'eip155:8453/slip44:60', // Base
+    'cosmos:cosmoshub-4/slip44:118', // Cosmos
+    'cosmos:osmosis-1/slip44:118', // Osmosis
+    'cosmos:thorchain-mainnet-v1/slip44:931', // Thorchain
+    'cosmos:mayachain-mainnet-v1/slip44:931', // Mayachain
+    'ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144', // XRP
+    'bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2', // Litecoin
+    'bip122:00000000001a91e3dace36e2be3bf030/slip44:3', // Dogecoin
+    'bip122:000007d91d1254d60e2dd1ae58038307/slip44:5', // Dash
+    'bip122:000000000000000000651ef99cb9fcbe/slip44:145', // Bitcoin Cash
+]);
 // NOTE: Rate limiting is now enforced at the worker level (pioneer-server)
 // using a Redis mutex to ensure ONLY ONE market API call at a time across all processes
 // The Bottleneck limiters below are kept as a safety net for direct module usage
+// Token bucket and metrics system
+var tokenBucketManager = null;
+var metricsLogger = null;
+var isInitializing = false;
 module.exports = {
     init: function (settings) {
         if (settings === null || settings === void 0 ? void 0 : settings.apiKey) {
             COINGECKO_API_KEY = settings.apiKey;
         }
         //if(!COINGECKO_API_KEY) throw Error("api key required! set env COINGECKO_API_KEY")
+        // Start hourly metrics reporting to Discord
+        (0, api_metrics_reporter_1.startHourlyReporting)();
     },
     // NEW: CAIP-first individual asset price lookup
     getAssetPriceByCaip: function (caip, returnSource) {
@@ -139,6 +173,26 @@ module.exports = {
     getBatchPricesByCaip: function (caips, returnSource) {
         return get_batch_prices_by_caip(caips, returnSource);
     },
+    // NEW: CCXT direct access (for testing/debugging)
+    getPriceFromCCXT: function (symbol) {
+        return (0, ccxt_pricing_1.getPriceFromCCXT)(symbol);
+    },
+    getBatchPricesFromCCXT: function (symbols) {
+        return (0, ccxt_pricing_1.getBatchPricesFromCCXT)(symbols);
+    },
+    // NEW: Metrics and monitoring
+    getCurrentMetrics: function () {
+        return (0, api_metrics_reporter_1.getCurrentMetrics)();
+    },
+    getUnpriceableTokens: function (limit) {
+        return (0, api_metrics_reporter_1.getUnpriceableTokens)(limit);
+    },
+    clearUnpriceableToken: function (caip) {
+        return (0, api_metrics_reporter_1.clearUnpriceableToken)(caip);
+    },
+    sendMetricsReport: function () {
+        return (0, api_metrics_reporter_1.sendHourlyMetricsReport)();
+    },
     // Legacy bulk fetch functions
     getAssetsCoinCap: function () {
         return get_assets_coincap();
@@ -163,6 +217,16 @@ module.exports = {
     },
     buildBalances: function (marketInfoCoinCap, marketInfoCoinGecko, pubkeys, context) {
         return build_balances(marketInfoCoinCap, marketInfoCoinGecko, pubkeys);
+    },
+    // NEW: Token bucket management
+    getTokenBucketManager: function () {
+        return tokenBucketManager;
+    },
+    getMetricsLogger: function () {
+        return metricsLogger;
+    },
+    initializeTokenBuckets: function () {
+        return initializeTokenBuckets();
     }
 };
 var update_cache = function () {
@@ -736,54 +800,151 @@ var is_unpriceable_token = function (caip) {
  * Cache token as unpriceable (not found in any of our 3 paid APIs)
  * Stores in-memory for instant lookups + Redis for persistence
  * This prevents wasting API calls on scam/spam tokens
+ *
+ * CRITICAL PROTECTION: Major cryptocurrencies are NEVER marked as unpriceable
+ * API failures for BTC, ETH, etc. are temporary - we retry instead of caching failure
  */
 var cache_unpriceable_token = function (caip) {
     return __awaiter(this, void 0, void 0, function () {
-        var tag, key;
+        var tag, error_1, key;
         return __generator(this, function (_a) {
-            tag = TAG + ' | cache_unpriceable_token | ';
-            // Store in-memory for instant lookups
-            unpriceableTokensCache.set(caip, {
-                markedAt: Date.now(),
-                maybeScam: true
-            });
-            // Also persist to Redis for cross-process sharing (but don't wait/block)
-            try {
-                key = UNPRICEABLE_TOKEN_PREFIX + caip;
-                redis.setex(key, UNPRICEABLE_TOKEN_TTL, JSON.stringify({
-                    caip: caip,
-                    markedAt: new Date().toISOString(),
-                    reason: 'not_found_in_paid_apis',
-                    maybeScam: true
-                })).catch(function (err) {
-                    // Ignore Redis errors - in-memory cache is primary
-                    log.debug(tag, "Redis error (non-blocking): ".concat(err.message));
-                });
-                log.info(tag, "\u2705 Cached token as unpriceable for 7 days: ".concat(caip));
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + ' | cache_unpriceable_token | ';
+                    // CRITICAL: Never mark major cryptocurrencies as unpriceable!
+                    // If all APIs fail for Bitcoin/Ethereum/etc., it's an API issue, not a scam token
+                    if (MAJOR_CRYPTO_WHITELIST.has(caip)) {
+                        log.error(tag, "\uD83D\uDEA8 BLOCKED: Attempted to mark major cryptocurrency as unpriceable: ".concat(caip));
+                        log.error(tag, "This indicates all 3 price APIs failed - likely rate limiting or API outage");
+                        log.error(tag, "NOT caching as unpriceable - will retry on next request");
+                        return [2 /*return*/]; // Do NOT cache - allow retries for major coins
+                    }
+                    // Store in-memory for instant lookups
+                    unpriceableTokensCache.set(caip, {
+                        markedAt: Date.now(),
+                        maybeScam: true
+                    });
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, redis.sadd(REDIS_UNPRICEABLE_SET, caip)];
+                case 2:
+                    _a.sent();
+                    log.debug(tag, "Added ".concat(caip, " to unpriceable tokens set"));
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _a.sent();
+                    log.debug(tag, "Error adding to unpriceable set: ".concat(error_1));
+                    return [3 /*break*/, 4];
+                case 4:
+                    // Also persist to Redis for cross-process sharing (but don't wait/block)
+                    try {
+                        key = UNPRICEABLE_TOKEN_PREFIX + caip;
+                        redis.setex(key, UNPRICEABLE_TOKEN_TTL, JSON.stringify({
+                            caip: caip,
+                            markedAt: new Date().toISOString(),
+                            reason: 'not_found_in_paid_apis',
+                            maybeScam: true
+                        })).catch(function (err) {
+                            // Ignore Redis errors - in-memory cache is primary
+                            log.debug(tag, "Redis error (non-blocking): ".concat(err.message));
+                        });
+                        log.info(tag, "\u2705 Cached token as unpriceable for 7 days: ".concat(caip));
+                    }
+                    catch (error) {
+                        // If Redis fails, don't block - in-memory cache is already set
+                        log.debug(tag, "Redis error caching unpriceable token (non-critical): ".concat(error));
+                    }
+                    return [2 /*return*/];
             }
-            catch (error) {
-                // If Redis fails, don't block - in-memory cache is already set
-                log.debug(tag, "Redis error caching unpriceable token (non-critical): ".concat(error));
+        });
+    });
+};
+/**
+ * Track API success/failure for monitoring
+ */
+var trackAPIMetric = function (api, success, error) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, metricsData, metrics, apiKey, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + ' | trackAPIMetric | ';
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, redis.get(REDIS_API_METRICS_KEY)];
+                case 2:
+                    metricsData = _a.sent();
+                    metrics = metricsData ? JSON.parse(metricsData) : {
+                        coingecko: { success: 0, failures: 0 },
+                        coinmarketcap: { success: 0, failures: 0 },
+                        coincap: { success: 0, failures: 0 },
+                        ccxt: { success: 0, failures: 0 },
+                        timestamp: Date.now()
+                    };
+                    apiKey = api.toLowerCase().replace(/[^a-z]/g, '');
+                    if (metrics[apiKey]) {
+                        if (success) {
+                            metrics[apiKey].success++;
+                        }
+                        else {
+                            metrics[apiKey].failures++;
+                            if (error) {
+                                metrics[apiKey].lastError = error;
+                            }
+                        }
+                    }
+                    // Save back to Redis (expires after 2 hours)
+                    return [4 /*yield*/, redis.setex(REDIS_API_METRICS_KEY, 7200, JSON.stringify(metrics))];
+                case 3:
+                    // Save back to Redis (expires after 2 hours)
+                    _a.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    error_2 = _a.sent();
+                    log.debug(tag, "Error tracking API metric: ".concat(error_2));
+                    return [3 /*break*/, 5];
+                case 5: return [2 /*return*/];
             }
-            return [2 /*return*/];
         });
     });
 };
 /**
  * Get price from CoinGecko by coin ID
- * Now with rate limiting to prevent API spam
+ * Now with token bucket rate limiting and metrics logging
  */
 var get_price_from_coingecko = function (coingeckoId) {
     return __awaiter(this, void 0, void 0, function () {
-        var tag, url, headers, response, price, error_1, status_3;
+        var tag, startTime, hasTokens, url, headers, response, responseTime, price, error_3, responseTime, status_3, wasRateLimited, discordNotifier, importError_1, alertError_1;
         var _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
                     tag = TAG + ' | get_price_from_coingecko | ';
-                    _b.label = 1;
+                    startTime = Date.now();
+                    if (!(tokenBucketManager && tokenBucketManager.isInitialized())) return [3 /*break*/, 4];
+                    return [4 /*yield*/, tokenBucketManager.tryConsume('coingecko', 1)];
                 case 1:
-                    _b.trys.push([1, 3, , 4]);
+                    hasTokens = _b.sent();
+                    if (!!hasTokens) return [3 /*break*/, 4];
+                    log.warn(tag, '🚫 CoinGecko token bucket exhausted! Skipping API call.');
+                    if (!metricsLogger) return [3 /*break*/, 3];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coingecko',
+                            endpoint: '/simple/price',
+                            success: false,
+                            wasThrottled: true,
+                            error: 'Token bucket exhausted',
+                            tokensUsed: 0,
+                            timestamp: new Date()
+                        })];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3: return [2 /*return*/, 0]; // Don't call API if no tokens!
+                case 4:
+                    _b.trys.push([4, 11, , 24]);
                     url = "".concat(URL_COINGECKO, "simple/price?ids=").concat(coingeckoId, "&vs_currencies=usd");
                     log.debug(tag, "Fetching from CoinGecko: ".concat(url));
                     headers = {};
@@ -791,26 +952,101 @@ var get_price_from_coingecko = function (coingeckoId) {
                         headers['x-cg-pro-api-key'] = COINGECKO_API_KEY;
                     }
                     return [4 /*yield*/, axios.get(url, { headers: headers })];
-                case 2:
+                case 5:
                     response = _b.sent();
-                    if (response.data && response.data[coingeckoId] && response.data[coingeckoId].usd) {
-                        price = parseFloat(response.data[coingeckoId].usd);
-                        log.debug(tag, "\u2705 CoinGecko price for ".concat(coingeckoId, ": $").concat(price));
-                        return [2 /*return*/, price];
-                    }
+                    responseTime = Date.now() - startTime;
+                    if (!(response.data && response.data[coingeckoId] && response.data[coingeckoId].usd)) return [3 /*break*/, 8];
+                    price = parseFloat(response.data[coingeckoId].usd);
+                    log.debug(tag, "\u2705 CoinGecko price for ".concat(coingeckoId, ": $").concat(price));
+                    if (!metricsLogger) return [3 /*break*/, 7];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coingecko',
+                            endpoint: '/simple/price',
+                            success: true,
+                            responseTime: responseTime,
+                            price: price,
+                            tokensUsed: 1,
+                            costUSD: 0.02,
+                            timestamp: new Date()
+                        })];
+                case 6:
+                    _b.sent();
+                    _b.label = 7;
+                case 7: return [2 /*return*/, price];
+                case 8:
                     log.debug(tag, "No price data from CoinGecko for ".concat(coingeckoId));
-                    return [2 /*return*/, 0];
-                case 3:
-                    error_1 = _b.sent();
-                    status_3 = ((_a = error_1.response) === null || _a === void 0 ? void 0 : _a.status) || error_1.status;
-                    if (status_3 === 429 || status_3 === 403) {
-                        log.warn(tag, "CoinGecko rate limit (".concat(status_3, ") for ").concat(coingeckoId));
-                    }
-                    else {
-                        log.debug(tag, "CoinGecko error for ".concat(coingeckoId, ": ").concat(error_1.message));
-                    }
-                    return [2 /*return*/, 0];
-                case 4: return [2 /*return*/];
+                    if (!metricsLogger) return [3 /*break*/, 10];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coingecko',
+                            endpoint: '/simple/price',
+                            success: false,
+                            responseTime: responseTime,
+                            error: 'No price data',
+                            tokensUsed: 1,
+                            costUSD: 0.02,
+                            timestamp: new Date()
+                        })];
+                case 9:
+                    _b.sent();
+                    _b.label = 10;
+                case 10: return [2 /*return*/, 0];
+                case 11:
+                    error_3 = _b.sent();
+                    responseTime = Date.now() - startTime;
+                    status_3 = ((_a = error_3.response) === null || _a === void 0 ? void 0 : _a.status) || error_3.status;
+                    wasRateLimited = status_3 === 429 || status_3 === 403;
+                    if (!metricsLogger) return [3 /*break*/, 13];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coingecko',
+                            endpoint: '/simple/price',
+                            success: false,
+                            responseTime: responseTime,
+                            statusCode: status_3,
+                            error: error_3.message,
+                            wasRateLimited: wasRateLimited,
+                            tokensUsed: 1, // Token was consumed even on error!
+                            costUSD: 0.02,
+                            timestamp: new Date()
+                        })];
+                case 12:
+                    _b.sent();
+                    _b.label = 13;
+                case 13:
+                    if (!wasRateLimited) return [3 /*break*/, 22];
+                    log.warn(tag, "CoinGecko rate limit (".concat(status_3, ") for ").concat(coingeckoId));
+                    _b.label = 14;
+                case 14:
+                    _b.trys.push([14, 20, , 21]);
+                    if (!(typeof require !== 'undefined')) return [3 /*break*/, 19];
+                    _b.label = 15;
+                case 15:
+                    _b.trys.push([15, 18, , 19]);
+                    discordNotifier = require('@pioneer-platform/pioneer-server/services/discord-notifier.service').discordNotifier;
+                    if (!(discordNotifier && discordNotifier.isEnabled())) return [3 /*break*/, 17];
+                    return [4 /*yield*/, discordNotifier.sendRateLimitAlert('CoinGecko', status_3, {
+                            endpoint: '/simple/price',
+                            asset: coingeckoId
+                        })];
+                case 16:
+                    _b.sent();
+                    _b.label = 17;
+                case 17: return [3 /*break*/, 19];
+                case 18:
+                    importError_1 = _b.sent();
+                    // Server context not available - running standalone, skip alert
+                    log.debug(tag, 'Discord notifier not available (standalone mode)');
+                    return [3 /*break*/, 19];
+                case 19: return [3 /*break*/, 21];
+                case 20:
+                    alertError_1 = _b.sent();
+                    log.debug(tag, 'Failed to send rate limit alert:', alertError_1);
+                    return [3 /*break*/, 21];
+                case 21: return [3 /*break*/, 23];
+                case 22:
+                    log.debug(tag, "CoinGecko error for ".concat(coingeckoId, ": ").concat(error_3.message));
+                    _b.label = 23;
+                case 23: return [2 /*return*/, 0];
+                case 24: return [2 /*return*/];
             }
         });
     });
@@ -822,7 +1058,7 @@ var get_price_from_coingecko = function (coingeckoId) {
  */
 var get_price_from_coingecko_contract = function (contractAddress_1) {
     return __awaiter(this, arguments, void 0, function (contractAddress, chainId) {
-        var tag, url, headers, response, contractKey, price, error_2, status_4;
+        var tag, url, headers, response, contractKey, price, error_4, status_4;
         var _a;
         if (chainId === void 0) { chainId = 'ethereum'; }
         return __generator(this, function (_b) {
@@ -850,13 +1086,13 @@ var get_price_from_coingecko_contract = function (contractAddress_1) {
                     log.debug(tag, "No price data from CoinGecko for contract ".concat(contractAddress));
                     return [2 /*return*/, 0];
                 case 3:
-                    error_2 = _b.sent();
-                    status_4 = ((_a = error_2.response) === null || _a === void 0 ? void 0 : _a.status) || error_2.status;
+                    error_4 = _b.sent();
+                    status_4 = ((_a = error_4.response) === null || _a === void 0 ? void 0 : _a.status) || error_4.status;
                     if (status_4 === 429 || status_4 === 403) {
                         log.warn(tag, "CoinGecko rate limit (".concat(status_4, ") for contract ").concat(contractAddress));
                     }
                     else {
-                        log.debug(tag, "CoinGecko contract error for ".concat(contractAddress, ": ").concat(error_2.message));
+                        log.debug(tag, "CoinGecko contract error for ".concat(contractAddress, ": ").concat(error_4.message));
                     }
                     return [2 /*return*/, 0];
                 case 4: return [2 /*return*/];
@@ -866,23 +1102,43 @@ var get_price_from_coingecko_contract = function (contractAddress_1) {
 };
 /**
  * Get price from CoinMarketCap by symbol
- * Now with rate limiting to prevent API spam
+ * Now with token bucket rate limiting and metrics logging
  */
 var get_price_from_coinmarketcap = function (symbol) {
     return __awaiter(this, void 0, void 0, function () {
-        var tag, url, response, coinData, priceData, price, error_3, status_5;
+        var tag, startTime, hasTokens, url, response, responseTime, coinData, priceData, price, error_5, responseTime, status_5, wasRateLimited, discordNotifier, importError_2, alertError_2;
         var _a, _b, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
                     tag = TAG + ' | get_price_from_coinmarketcap | ';
+                    startTime = Date.now();
                     if (!CMC_PRO_API_KEY) {
                         log.debug(tag, 'CMC_PRO_API_KEY not set, skipping CoinMarketCap');
                         return [2 /*return*/, 0];
                     }
-                    _d.label = 1;
+                    if (!(tokenBucketManager && tokenBucketManager.isInitialized())) return [3 /*break*/, 4];
+                    return [4 /*yield*/, tokenBucketManager.tryConsume('coinmarketcap', 1)];
                 case 1:
-                    _d.trys.push([1, 3, , 4]);
+                    hasTokens = _d.sent();
+                    if (!!hasTokens) return [3 /*break*/, 4];
+                    log.warn(tag, '🚫 CoinMarketCap token bucket exhausted! Skipping API call.');
+                    if (!metricsLogger) return [3 /*break*/, 3];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coinmarketcap',
+                            endpoint: '/cryptocurrency/quotes/latest',
+                            success: false,
+                            wasThrottled: true,
+                            error: 'Token bucket exhausted',
+                            tokensUsed: 0,
+                            timestamp: new Date()
+                        })];
+                case 2:
+                    _d.sent();
+                    _d.label = 3;
+                case 3: return [2 /*return*/, 0];
+                case 4:
+                    _d.trys.push([4, 14, , 27]);
                     url = "".concat(URL_COINMARKETCAP, "cryptocurrency/quotes/latest?symbol=").concat(symbol, "&convert=USD");
                     log.debug(tag, "Fetching from CoinMarketCap: ".concat(url));
                     return [4 /*yield*/, axios.get(url, {
@@ -891,56 +1147,164 @@ var get_price_from_coinmarketcap = function (symbol) {
                                 'Accept': 'application/json'
                             }
                         })];
-                case 2:
+                case 5:
                     response = _d.sent();
-                    if (response.data && response.data.data && response.data.data[symbol]) {
-                        coinData = response.data.data[symbol];
-                        priceData = (_b = (_a = coinData.quote) === null || _a === void 0 ? void 0 : _a.USD) === null || _b === void 0 ? void 0 : _b.price;
-                        if (!priceData || isNaN(parseFloat(priceData))) {
-                            log.warn(tag, "\u26A0\uFE0F CoinMarketCap returned invalid price for ".concat(symbol));
-                            log.warn(tag, "Symbol: ".concat(coinData.symbol, ", Slug: ").concat(coinData.slug, ", Quote keys:"), Object.keys(coinData.quote || {}));
-                            return [2 /*return*/, 0];
-                        }
-                        price = parseFloat(priceData);
-                        log.debug(tag, "\u2705 CoinMarketCap price for ".concat(symbol, ": $").concat(price));
-                        return [2 /*return*/, price];
-                    }
+                    responseTime = Date.now() - startTime;
+                    if (!(response.data && response.data.data && response.data.data[symbol])) return [3 /*break*/, 11];
+                    coinData = response.data.data[symbol];
+                    priceData = (_b = (_a = coinData.quote) === null || _a === void 0 ? void 0 : _a.USD) === null || _b === void 0 ? void 0 : _b.price;
+                    if (!(!priceData || isNaN(parseFloat(priceData)))) return [3 /*break*/, 8];
+                    log.warn(tag, "\u26A0\uFE0F CoinMarketCap returned invalid price for ".concat(symbol));
+                    if (!metricsLogger) return [3 /*break*/, 7];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coinmarketcap',
+                            endpoint: '/cryptocurrency/quotes/latest',
+                            success: false,
+                            responseTime: responseTime,
+                            error: 'Invalid price data',
+                            tokensUsed: 1,
+                            costUSD: 0.015,
+                            timestamp: new Date()
+                        })];
+                case 6:
+                    _d.sent();
+                    _d.label = 7;
+                case 7: return [2 /*return*/, 0];
+                case 8:
+                    price = parseFloat(priceData);
+                    log.debug(tag, "\u2705 CoinMarketCap price for ".concat(symbol, ": $").concat(price));
+                    if (!metricsLogger) return [3 /*break*/, 10];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coinmarketcap',
+                            endpoint: '/cryptocurrency/quotes/latest',
+                            success: true,
+                            responseTime: responseTime,
+                            price: price,
+                            tokensUsed: 1,
+                            costUSD: 0.015,
+                            timestamp: new Date()
+                        })];
+                case 9:
+                    _d.sent();
+                    _d.label = 10;
+                case 10: return [2 /*return*/, price];
+                case 11:
                     log.debug(tag, "No price data from CoinMarketCap for ".concat(symbol));
-                    return [2 /*return*/, 0];
-                case 3:
-                    error_3 = _d.sent();
-                    status_5 = ((_c = error_3.response) === null || _c === void 0 ? void 0 : _c.status) || error_3.status;
-                    if (status_5 === 429 || status_5 === 403) {
-                        log.warn(tag, "CoinMarketCap rate limit (".concat(status_5, ") for ").concat(symbol));
-                    }
-                    else {
-                        log.debug(tag, "CoinMarketCap error for ".concat(symbol, ": ").concat(error_3.message));
-                    }
-                    return [2 /*return*/, 0];
-                case 4: return [2 /*return*/];
+                    if (!metricsLogger) return [3 /*break*/, 13];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coinmarketcap',
+                            endpoint: '/cryptocurrency/quotes/latest',
+                            success: false,
+                            responseTime: responseTime,
+                            error: 'No price data',
+                            tokensUsed: 1,
+                            costUSD: 0.015,
+                            timestamp: new Date()
+                        })];
+                case 12:
+                    _d.sent();
+                    _d.label = 13;
+                case 13: return [2 /*return*/, 0];
+                case 14:
+                    error_5 = _d.sent();
+                    responseTime = Date.now() - startTime;
+                    status_5 = ((_c = error_5.response) === null || _c === void 0 ? void 0 : _c.status) || error_5.status;
+                    wasRateLimited = status_5 === 429 || status_5 === 403;
+                    if (!metricsLogger) return [3 /*break*/, 16];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coinmarketcap',
+                            endpoint: '/cryptocurrency/quotes/latest',
+                            success: false,
+                            responseTime: responseTime,
+                            statusCode: status_5,
+                            error: error_5.message,
+                            wasRateLimited: wasRateLimited,
+                            tokensUsed: 1,
+                            costUSD: 0.015,
+                            timestamp: new Date()
+                        })];
+                case 15:
+                    _d.sent();
+                    _d.label = 16;
+                case 16:
+                    if (!wasRateLimited) return [3 /*break*/, 25];
+                    log.warn(tag, "CoinMarketCap rate limit (".concat(status_5, ") for ").concat(symbol));
+                    _d.label = 17;
+                case 17:
+                    _d.trys.push([17, 23, , 24]);
+                    if (!(typeof require !== 'undefined')) return [3 /*break*/, 22];
+                    _d.label = 18;
+                case 18:
+                    _d.trys.push([18, 21, , 22]);
+                    discordNotifier = require('@pioneer-platform/pioneer-server/services/discord-notifier.service').discordNotifier;
+                    if (!(discordNotifier && discordNotifier.isEnabled())) return [3 /*break*/, 20];
+                    return [4 /*yield*/, discordNotifier.sendRateLimitAlert('CoinMarketCap', status_5, {
+                            endpoint: '/cryptocurrency/quotes/latest',
+                            symbol: symbol
+                        })];
+                case 19:
+                    _d.sent();
+                    _d.label = 20;
+                case 20: return [3 /*break*/, 22];
+                case 21:
+                    importError_2 = _d.sent();
+                    // Server context not available - running standalone, skip alert
+                    log.debug(tag, 'Discord notifier not available (standalone mode)');
+                    return [3 /*break*/, 22];
+                case 22: return [3 /*break*/, 24];
+                case 23:
+                    alertError_2 = _d.sent();
+                    log.debug(tag, 'Failed to send rate limit alert:', alertError_2);
+                    return [3 /*break*/, 24];
+                case 24: return [3 /*break*/, 26];
+                case 25:
+                    log.debug(tag, "CoinMarketCap error for ".concat(symbol, ": ").concat(error_5.message));
+                    _d.label = 26;
+                case 26: return [2 /*return*/, 0];
+                case 27: return [2 /*return*/];
             }
         });
     });
 };
 /**
  * Get price from CoinCap by symbol
- * Now with rate limiting to prevent API spam
+ * Now with token bucket rate limiting and metrics logging
  */
 var get_price_from_coincap = function (symbol) {
     return __awaiter(this, void 0, void 0, function () {
-        var tag, url, response, price, error_4, status_6;
+        var tag, startTime, hasTokens, url, response, responseTime, price, error_6, responseTime, status_6, wasRateLimited, discordNotifier, importError_3, alertError_3;
         var _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
                     tag = TAG + ' | get_price_from_coincap | ';
+                    startTime = Date.now();
                     if (!COINCAP_API_KEY) {
                         log.debug(tag, 'COINCAP_API_KEY not set, skipping CoinCap');
                         return [2 /*return*/, 0];
                     }
-                    _b.label = 1;
+                    if (!(tokenBucketManager && tokenBucketManager.isInitialized())) return [3 /*break*/, 4];
+                    return [4 /*yield*/, tokenBucketManager.tryConsume('coincap', 1)];
                 case 1:
-                    _b.trys.push([1, 3, , 4]);
+                    hasTokens = _b.sent();
+                    if (!!hasTokens) return [3 /*break*/, 4];
+                    log.warn(tag, '🚫 CoinCap token bucket exhausted! Skipping API call.');
+                    if (!metricsLogger) return [3 /*break*/, 3];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coincap',
+                            endpoint: '/assets',
+                            success: false,
+                            wasThrottled: true,
+                            error: 'Token bucket exhausted',
+                            tokensUsed: 0,
+                            timestamp: new Date()
+                        })];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3: return [2 /*return*/, 0];
+                case 4:
+                    _b.trys.push([4, 11, , 24]);
                     url = "".concat(URL_COINCAP, "assets/").concat(symbol);
                     log.debug(tag, "Fetching from CoinCap: ".concat(url));
                     return [4 /*yield*/, axios.get(url, {
@@ -949,26 +1313,101 @@ var get_price_from_coincap = function (symbol) {
                                 'Authorization': "Bearer ".concat(COINCAP_API_KEY)
                             }
                         })];
-                case 2:
+                case 5:
                     response = _b.sent();
-                    if (response.data && response.data.data && response.data.data.priceUsd) {
-                        price = parseFloat(response.data.data.priceUsd);
-                        log.debug(tag, "\u2705 CoinCap price for ".concat(symbol, ": $").concat(price));
-                        return [2 /*return*/, price];
-                    }
+                    responseTime = Date.now() - startTime;
+                    if (!(response.data && response.data.data && response.data.data.priceUsd)) return [3 /*break*/, 8];
+                    price = parseFloat(response.data.data.priceUsd);
+                    log.debug(tag, "\u2705 CoinCap price for ".concat(symbol, ": $").concat(price));
+                    if (!metricsLogger) return [3 /*break*/, 7];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coincap',
+                            endpoint: '/assets',
+                            success: true,
+                            responseTime: responseTime,
+                            price: price,
+                            tokensUsed: 1,
+                            costUSD: 0.01,
+                            timestamp: new Date()
+                        })];
+                case 6:
+                    _b.sent();
+                    _b.label = 7;
+                case 7: return [2 /*return*/, price];
+                case 8:
                     log.debug(tag, "No price data from CoinCap for ".concat(symbol));
-                    return [2 /*return*/, 0];
-                case 3:
-                    error_4 = _b.sent();
-                    status_6 = ((_a = error_4.response) === null || _a === void 0 ? void 0 : _a.status) || error_4.status;
-                    if (status_6 === 429 || status_6 === 403) {
-                        log.warn(tag, "CoinCap rate limit (".concat(status_6, ") for ").concat(symbol));
-                    }
-                    else {
-                        log.debug(tag, "CoinCap error for ".concat(symbol, ": ").concat(error_4.message));
-                    }
-                    return [2 /*return*/, 0];
-                case 4: return [2 /*return*/];
+                    if (!metricsLogger) return [3 /*break*/, 10];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coincap',
+                            endpoint: '/assets',
+                            success: false,
+                            responseTime: responseTime,
+                            error: 'No price data',
+                            tokensUsed: 1,
+                            costUSD: 0.01,
+                            timestamp: new Date()
+                        })];
+                case 9:
+                    _b.sent();
+                    _b.label = 10;
+                case 10: return [2 /*return*/, 0];
+                case 11:
+                    error_6 = _b.sent();
+                    responseTime = Date.now() - startTime;
+                    status_6 = ((_a = error_6.response) === null || _a === void 0 ? void 0 : _a.status) || error_6.status;
+                    wasRateLimited = status_6 === 429 || status_6 === 403;
+                    if (!metricsLogger) return [3 /*break*/, 13];
+                    return [4 /*yield*/, metricsLogger.logAPICall({
+                            apiName: 'coincap',
+                            endpoint: '/assets',
+                            success: false,
+                            responseTime: responseTime,
+                            statusCode: status_6,
+                            error: error_6.message,
+                            wasRateLimited: wasRateLimited,
+                            tokensUsed: 1,
+                            costUSD: 0.01,
+                            timestamp: new Date()
+                        })];
+                case 12:
+                    _b.sent();
+                    _b.label = 13;
+                case 13:
+                    if (!wasRateLimited) return [3 /*break*/, 22];
+                    log.warn(tag, "CoinCap rate limit (".concat(status_6, ") for ").concat(symbol));
+                    _b.label = 14;
+                case 14:
+                    _b.trys.push([14, 20, , 21]);
+                    if (!(typeof require !== 'undefined')) return [3 /*break*/, 19];
+                    _b.label = 15;
+                case 15:
+                    _b.trys.push([15, 18, , 19]);
+                    discordNotifier = require('@pioneer-platform/pioneer-server/services/discord-notifier.service').discordNotifier;
+                    if (!(discordNotifier && discordNotifier.isEnabled())) return [3 /*break*/, 17];
+                    return [4 /*yield*/, discordNotifier.sendRateLimitAlert('CoinCap', status_6, {
+                            endpoint: '/assets',
+                            symbol: symbol
+                        })];
+                case 16:
+                    _b.sent();
+                    _b.label = 17;
+                case 17: return [3 /*break*/, 19];
+                case 18:
+                    importError_3 = _b.sent();
+                    // Server context not available - running standalone, skip alert
+                    log.debug(tag, 'Discord notifier not available (standalone mode)');
+                    return [3 /*break*/, 19];
+                case 19: return [3 /*break*/, 21];
+                case 20:
+                    alertError_3 = _b.sent();
+                    log.debug(tag, 'Failed to send rate limit alert:', alertError_3);
+                    return [3 /*break*/, 21];
+                case 21: return [3 /*break*/, 23];
+                case 22:
+                    log.debug(tag, "CoinCap error for ".concat(symbol, ": ").concat(error_6.message));
+                    _b.label = 23;
+                case 23: return [2 /*return*/, 0];
+                case 24: return [2 /*return*/];
             }
         });
     });
@@ -980,7 +1419,7 @@ var get_price_from_coincap = function (symbol) {
  */
 var get_price_from_mayascan = function () {
     return __awaiter(this, arguments, void 0, function (asset) {
-        var tag, url, response, price, error_5;
+        var tag, url, response, price, error_7;
         if (asset === void 0) { asset = 'maya'; }
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -1010,8 +1449,8 @@ var get_price_from_mayascan = function () {
                     log.debug(tag, "No ".concat(asset.toUpperCase(), " price data from MayaScan"));
                     return [2 /*return*/, 0];
                 case 3:
-                    error_5 = _a.sent();
-                    log.debug(tag, "MayaScan error: ".concat(error_5.message));
+                    error_7 = _a.sent();
+                    log.debug(tag, "MayaScan error: ".concat(error_7.message));
                     return [2 /*return*/, 0];
                 case 4: return [2 /*return*/];
             }
@@ -1052,7 +1491,8 @@ var get_asset_price_by_caip = function (caip_2) {
  */
 var get_asset_price_by_caip_internal = function (caip_2) {
     return __awaiter(this, arguments, void 0, function (caip, returnSource) {
-        var tag, mayaPrice, isCacao, identifiers, price, contractAddress, chainIdMatch, chainId, chainMap, platformName, asset, symbol, cacaoPrice;
+        var tag, mayaPrice, isCacao, identifiers, price, apiStrategies, shuffledStrategies, _i, shuffledStrategies_1, strategy, error_8, contractAddress, chainIdMatch, chainId, chainMap, platformName, asset, symbol, cacaoPrice, ccxtPrice, ccxtError_1;
+        var _this = this;
         if (returnSource === void 0) { returnSource = false; }
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -1078,26 +1518,138 @@ var get_asset_price_by_caip_internal = function (caip_2) {
                     isCacao = caip === 'cosmos:mayachain-mainnet-v1/slip44:931';
                     identifiers = caip_to_identifiers(caip);
                     price = 0;
-                    if (!identifiers) return [3 /*break*/, 4];
+                    if (!identifiers) return [3 /*break*/, 14];
                     log.debug(tag, "Identifiers for ".concat(caip, ":"), identifiers);
-                    // Try CoinGecko with mapped ID
-                    console.log("\uD83E\uDD8E Trying CoinGecko with mapped ID: ".concat(identifiers.coingeckoId));
-                    return [4 /*yield*/, get_price_from_coingecko(identifiers.coingeckoId)];
+                    apiStrategies = [
+                        {
+                            name: 'CoinGecko',
+                            icon: '🦎',
+                            fetch: function () { return __awaiter(_this, void 0, void 0, function () {
+                                var p;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            console.log("\uD83E\uDD8E Trying CoinGecko with mapped ID: ".concat(identifiers.coingeckoId));
+                                            return [4 /*yield*/, get_price_from_coingecko(identifiers.coingeckoId)];
+                                        case 1:
+                                            p = _a.sent();
+                                            console.log("\uD83E\uDD8E CoinGecko returned price: $".concat(p));
+                                            return [2 /*return*/, p];
+                                    }
+                                });
+                            }); },
+                            source: 'coingecko'
+                        },
+                        {
+                            name: 'CoinMarketCap',
+                            icon: '📊',
+                            fetch: function () { return __awaiter(_this, void 0, void 0, function () {
+                                var p;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            console.log("\uD83D\uDCCA Trying CoinMarketCap for: ".concat(identifiers.cmcSymbol));
+                                            return [4 /*yield*/, get_price_from_coinmarketcap(identifiers.cmcSymbol)];
+                                        case 1:
+                                            p = _a.sent();
+                                            console.log("\uD83D\uDCCA CoinMarketCap returned price: $".concat(p));
+                                            return [2 /*return*/, p];
+                                    }
+                                });
+                            }); },
+                            source: 'coinmarketcap'
+                        },
+                        {
+                            name: 'CoinCap',
+                            icon: '💰',
+                            fetch: function () { return __awaiter(_this, void 0, void 0, function () {
+                                var p;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            console.log("\uD83D\uDCB0 Trying CoinCap for: ".concat(identifiers.coincapSymbol));
+                                            return [4 /*yield*/, get_price_from_coincap(identifiers.coincapSymbol)];
+                                        case 1:
+                                            p = _a.sent();
+                                            console.log("\uD83D\uDCB0 CoinCap returned price: $".concat(p));
+                                            return [2 /*return*/, p];
+                                    }
+                                });
+                            }); },
+                            source: 'coincap'
+                        },
+                        {
+                            name: 'CCXT',
+                            icon: '🔄',
+                            fetch: function () { return __awaiter(_this, void 0, void 0, function () {
+                                var p;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            console.log("\uD83D\uDD04 Trying CCXT for: ".concat(identifiers.symbol));
+                                            return [4 /*yield*/, (0, ccxt_pricing_1.getPriceFromCCXT)(identifiers.symbol)];
+                                        case 1:
+                                            p = _a.sent();
+                                            console.log("\uD83D\uDD04 CCXT returned price: $".concat(p));
+                                            return [2 /*return*/, p];
+                                    }
+                                });
+                            }); },
+                            source: 'ccxt'
+                        }
+                    ];
+                    shuffledStrategies = apiStrategies.sort(function () { return Math.random() - 0.5; });
+                    log.debug(tag, "Randomized API order: ".concat(shuffledStrategies.map(function (s) { return s.name; }).join(' → ')));
+                    _i = 0, shuffledStrategies_1 = shuffledStrategies;
+                    _a.label = 3;
                 case 3:
-                    price = _a.sent();
-                    console.log("\uD83E\uDD8E CoinGecko returned price: $".concat(price));
-                    if (price > 0) {
-                        return [2 /*return*/, returnSource ? { price: price, source: 'coingecko' } : price];
-                    }
-                    return [3 /*break*/, 5];
+                    if (!(_i < shuffledStrategies_1.length)) return [3 /*break*/, 13];
+                    strategy = shuffledStrategies_1[_i];
+                    _a.label = 4;
                 case 4:
-                    log.debug(tag, "No identifier mapping found for CAIP: ".concat(caip));
-                    _a.label = 5;
+                    _a.trys.push([4, 10, , 12]);
+                    return [4 /*yield*/, strategy.fetch()];
                 case 5:
-                    if (!caip.includes('/erc20:0x')) return [3 /*break*/, 13];
+                    price = _a.sent();
+                    if (!(price > 0)) return [3 /*break*/, 7];
+                    log.info(tag, "\u2705 Got price from ".concat(strategy.name, ": $").concat(price));
+                    // Track successful API call
+                    return [4 /*yield*/, trackAPIMetric(strategy.source, true)];
+                case 6:
+                    // Track successful API call
+                    _a.sent();
+                    return [2 /*return*/, returnSource ? { price: price, source: strategy.source } : price];
+                case 7: 
+                // Track failure (0 price returned)
+                return [4 /*yield*/, trackAPIMetric(strategy.source, false, 'Returned 0 price')];
+                case 8:
+                    // Track failure (0 price returned)
+                    _a.sent();
+                    _a.label = 9;
+                case 9: return [3 /*break*/, 12];
+                case 10:
+                    error_8 = _a.sent();
+                    log.debug(tag, "".concat(strategy.name, " failed:"), error_8);
+                    // Track failure with error message
+                    return [4 /*yield*/, trackAPIMetric(strategy.source, false, error_8.message)];
+                case 11:
+                    // Track failure with error message
+                    _a.sent();
+                    return [3 /*break*/, 12];
+                case 12:
+                    _i++;
+                    return [3 /*break*/, 3];
+                case 13:
+                    log.debug(tag, "All APIs returned 0 or failed for ".concat(caip));
+                    return [3 /*break*/, 15];
+                case 14:
+                    log.debug(tag, "No identifier mapping found for CAIP: ".concat(caip));
+                    _a.label = 15;
+                case 15:
+                    if (!caip.includes('/erc20:0x')) return [3 /*break*/, 23];
                     contractAddress = caip.split('/erc20:')[1];
                     chainIdMatch = caip.match(/eip155:(\d+)/);
-                    if (!(contractAddress && chainIdMatch)) return [3 /*break*/, 7];
+                    if (!(contractAddress && chainIdMatch)) return [3 /*break*/, 17];
                     chainId = chainIdMatch[1];
                     chainMap = {
                         '1': 'ethereum',
@@ -1112,23 +1664,23 @@ var get_asset_price_by_caip_internal = function (caip_2) {
                     platformName = chainMap[chainId] || 'ethereum';
                     console.log("\uD83D\uDD04 Trying CoinGecko contract lookup: ".concat(contractAddress, " on ").concat(platformName));
                     return [4 /*yield*/, get_price_from_coingecko_contract(contractAddress, platformName)];
-                case 6:
+                case 16:
                     price = _a.sent();
                     console.log("\uD83D\uDD04 CoinGecko contract returned price: $".concat(price));
                     if (price > 0) {
                         return [2 /*return*/, returnSource ? { price: price, source: 'coingecko-contract' } : price];
                     }
-                    _a.label = 7;
-                case 7:
-                    if (!(price === 0)) return [3 /*break*/, 13];
+                    _a.label = 17;
+                case 17:
+                    if (!(price === 0)) return [3 /*break*/, 23];
                     asset = pioneer_discovery_1.assetData[caip] || pioneer_discovery_1.assetData[caip.toUpperCase()] || pioneer_discovery_1.assetData[caip.toLowerCase()];
-                    if (!(asset && asset.symbol)) return [3 /*break*/, 11];
+                    if (!(asset && asset.symbol)) return [3 /*break*/, 21];
                     symbol = asset.symbol.toUpperCase();
                     log.info(tag, "\uD83D\uDD04 Contract lookup failed, falling back to symbol-based APIs for: ".concat(symbol));
                     // Try CoinMarketCap
                     console.log("\uD83D\uDCCA Trying CoinMarketCap for ERC20 token: ".concat(symbol));
                     return [4 /*yield*/, get_price_from_coinmarketcap(symbol)];
-                case 8:
+                case 18:
                     price = _a.sent();
                     console.log("\uD83D\uDCCA CoinMarketCap returned price: $".concat(price));
                     if (price > 0) {
@@ -1137,7 +1689,7 @@ var get_asset_price_by_caip_internal = function (caip_2) {
                     // Try CoinCap
                     console.log("\uD83D\uDCB0 Trying CoinCap for ERC20 token: ".concat(symbol.toLowerCase()));
                     return [4 /*yield*/, get_price_from_coincap(symbol.toLowerCase())];
-                case 9:
+                case 19:
                     price = _a.sent();
                     console.log("\uD83D\uDCB0 CoinCap returned price: $".concat(price));
                     if (price > 0) {
@@ -1145,38 +1697,52 @@ var get_asset_price_by_caip_internal = function (caip_2) {
                     }
                     // All 3 paid APIs failed - mark as unpriceable (likely scam/spam token)
                     log.warn(tag, "\u274C Token not found in any of 3 paid APIs (CoinGecko, CMC, CoinCap): ".concat(caip));
+                    // CRITICAL: Double-check this isn't a major crypto before marking unpriceable
+                    if (MAJOR_CRYPTO_WHITELIST.has(caip)) {
+                        log.error(tag, "\uD83D\uDEA8 CRITICAL: Major crypto ".concat(caip, " failed all API lookups!"));
+                        log.error(tag, "This indicates API outage or rate limiting - NOT marking as unpriceable");
+                        return [2 /*return*/, returnSource ? { price: 0, source: 'api_failure' } : 0];
+                    }
                     log.warn(tag, "\uD83D\uDEA8 Marking as maybeScam - will not retry pricing for this token");
                     // Cache the failure so we never try again
                     return [4 /*yield*/, cache_unpriceable_token(caip)];
-                case 10:
+                case 20:
                     // Cache the failure so we never try again
                     _a.sent();
                     return [2 /*return*/, returnSource ? { price: 0, source: 'unpriceable', maybeScam: true } : 0];
-                case 11:
+                case 21:
                     // Token not in our discovery database - can't get symbol for API calls
                     log.warn(tag, "\u274C Token not in discovery database, cannot lookup symbol: ".concat(caip));
                     log.warn(tag, "\uD83D\uDEA8 Marking as maybeScam - likely user-added spam token");
                     // Cache the failure so we never try again
                     return [4 /*yield*/, cache_unpriceable_token(caip)];
-                case 12:
+                case 22:
                     // Cache the failure so we never try again
                     _a.sent();
                     return [2 /*return*/, returnSource ? { price: 0, source: 'unpriceable', maybeScam: true } : 0];
-                case 13:
-                    if (!!identifiers) return [3 /*break*/, 15];
+                case 23:
+                    if (!!identifiers) return [3 /*break*/, 25];
                     log.warn(tag, "No way to lookup price for CAIP: ".concat(caip, " (no mapping, not ERC20, or all lookups failed)"));
+                    // CRITICAL: Never mark major cryptocurrencies as unpriceable!
+                    // This is a second layer of protection in case whitelist check fails
+                    if (MAJOR_CRYPTO_WHITELIST.has(caip)) {
+                        log.error(tag, "\uD83D\uDEA8 MAJOR CRYPTO WITHOUT IDENTIFIERS: ".concat(caip));
+                        log.error(tag, "This should NEVER happen - check coingeckoMapping and assetData");
+                        log.error(tag, "Returning 0 but NOT caching as unpriceable");
+                        return [2 /*return*/, returnSource ? { price: 0, source: 'mapping_error' } : 0];
+                    }
                     log.warn(tag, "\uD83D\uDEA8 Marking as maybeScam - token has no price source");
                     // Cache the failure so we never try again
                     return [4 /*yield*/, cache_unpriceable_token(caip)];
-                case 14:
+                case 24:
                     // Cache the failure so we never try again
                     _a.sent();
                     return [2 /*return*/, returnSource ? { price: 0, source: 'unpriceable', maybeScam: true } : 0];
-                case 15:
+                case 25:
                     // STEP 4: Try CoinMarketCap by symbol (requires API key)
                     console.log("\uD83D\uDCCA Trying CoinMarketCap for: ".concat(identifiers.cmcSymbol));
                     return [4 /*yield*/, get_price_from_coinmarketcap(identifiers.cmcSymbol)];
-                case 16:
+                case 26:
                     price = _a.sent();
                     console.log("\uD83D\uDCCA CoinMarketCap returned price: $".concat(price));
                     if (price > 0) {
@@ -1185,23 +1751,41 @@ var get_asset_price_by_caip_internal = function (caip_2) {
                     // STEP 5: Try CoinCap by symbol (last resort)
                     console.log("\uD83D\uDCB0 Trying CoinCap for: ".concat(identifiers.coincapSymbol));
                     return [4 /*yield*/, get_price_from_coincap(identifiers.coincapSymbol)];
-                case 17:
+                case 27:
                     price = _a.sent();
                     console.log("\uD83D\uDCB0 CoinCap returned price: $".concat(price));
                     if (price > 0) {
                         return [2 /*return*/, returnSource ? { price: price, source: 'coincap' } : price];
                     }
-                    if (!isCacao) return [3 /*break*/, 19];
+                    if (!isCacao) return [3 /*break*/, 29];
                     log.debug(tag, '🏔️ All pricing APIs failed for CACAO, trying MayaScan as final fallback');
                     return [4 /*yield*/, get_price_from_mayascan('cacao')];
-                case 18:
+                case 28:
                     cacaoPrice = _a.sent();
                     if (cacaoPrice > 0) {
                         return [2 /*return*/, returnSource ? { price: cacaoPrice, source: 'mayascan' } : cacaoPrice];
                     }
-                    _a.label = 19;
-                case 19:
-                    log.warn(tag, "\u274C No price found from any API for: ".concat(caip));
+                    _a.label = 29;
+                case 29:
+                    if (!(identifiers && identifiers.symbol)) return [3 /*break*/, 33];
+                    log.debug(tag, "\uD83D\uDD04 Trying CCXT as final fallback for: ".concat(identifiers.symbol));
+                    _a.label = 30;
+                case 30:
+                    _a.trys.push([30, 32, , 33]);
+                    return [4 /*yield*/, (0, ccxt_pricing_1.getPriceFromCCXT)(identifiers.symbol)];
+                case 31:
+                    ccxtPrice = _a.sent();
+                    if (ccxtPrice > 0) {
+                        log.info(tag, "\u2705 Got price from CCXT for ".concat(caip, ": $").concat(ccxtPrice));
+                        return [2 /*return*/, returnSource ? { price: ccxtPrice, source: 'ccxt' } : ccxtPrice];
+                    }
+                    return [3 /*break*/, 33];
+                case 32:
+                    ccxtError_1 = _a.sent();
+                    log.debug(tag, "CCXT lookup failed for ".concat(identifiers.symbol, ":"), ccxtError_1);
+                    return [3 /*break*/, 33];
+                case 33:
+                    log.warn(tag, "\u274C No price found from any API (including CCXT) for: ".concat(caip));
                     return [2 /*return*/, returnSource ? { price: 0, source: 'none' } : 0];
             }
         });
@@ -1346,7 +1930,7 @@ var get_price = function (asset) {
  */
 var get_batch_prices_by_caip = function (caips_1) {
     return __awaiter(this, arguments, void 0, function (caips, returnSource) {
-        var tag, results, caipToIdMap, specialCaips, _i, caips_2, caip, identifiers, coingeckoIds, batchSize, i, batch, idsParam, url, response, _a, batch_1, coingeckoId, mapping, price, error_6, _b, specialCaips_1, caip, price, error_7, missingCaips, _c, missingCaips_1, caip, _d, _e, error_8;
+        var tag, results, caipToIdMap, specialCaips, _i, caips_2, caip, identifiers, coingeckoIds, batchSize, i, batch, idsParam, url, response, _a, batch_1, coingeckoId, mapping, price, error_9, _b, specialCaips_1, caip, price, error_10, missingCaips, _c, missingCaips_1, caip, _d, _e, error_11;
         var _f;
         if (returnSource === void 0) { returnSource = false; }
         return __generator(this, function (_g) {
@@ -1413,8 +1997,8 @@ var get_batch_prices_by_caip = function (caips_1) {
                     log.info(tag, "\u2705 Batch fetched ".concat(Object.keys(results).length, " prices from CoinGecko"));
                     return [3 /*break*/, 8];
                 case 7:
-                    error_6 = _g.sent();
-                    log.error(tag, "CoinGecko batch fetch failed:", error_6.message);
+                    error_9 = _g.sent();
+                    log.error(tag, "CoinGecko batch fetch failed:", error_9.message);
                     return [3 /*break*/, 8];
                 case 8:
                     _b = 0, specialCaips_1 = specialCaips;
@@ -1431,7 +2015,7 @@ var get_batch_prices_by_caip = function (caips_1) {
                     results[caip] = price;
                     return [3 /*break*/, 13];
                 case 12:
-                    error_7 = _g.sent();
+                    error_10 = _g.sent();
                     log.warn(tag, "Failed to fetch special case: ".concat(caip));
                     return [3 /*break*/, 13];
                 case 13:
@@ -1456,7 +2040,7 @@ var get_batch_prices_by_caip = function (caips_1) {
                     _d[_e] = _g.sent();
                     return [3 /*break*/, 19];
                 case 18:
-                    error_8 = _g.sent();
+                    error_11 = _g.sent();
                     log.warn(tag, "Failed to fetch fallback price for ".concat(caip));
                     results[caip] = returnSource ? { price: 0, source: 'none' } : 0;
                     return [3 /*break*/, 19];
@@ -1470,3 +2054,58 @@ var get_batch_prices_by_caip = function (caips_1) {
         });
     });
 };
+/**
+ * Initialize token buckets and metrics logging
+ * Call this on module load
+ */
+function initializeTokenBuckets() {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, mongo, db, error_12;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + ' | initializeTokenBuckets | ';
+                    // Prevent double initialization
+                    if (isInitializing || tokenBucketManager) {
+                        log.debug(tag, 'Token buckets already initialized or initializing');
+                        return [2 /*return*/];
+                    }
+                    isInitializing = true;
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, 4, 5]);
+                    log.info(tag, 'Initializing token bucket system...');
+                    mongo = require('@pioneer-platform/default-mongo').mongo;
+                    db = mongo.db('pioneer');
+                    // Initialize metrics logger first
+                    metricsLogger = new metrics_logger_1.MetricsLogger(db);
+                    log.info(tag, '✅ MetricsLogger initialized');
+                    // Initialize token bucket manager
+                    tokenBucketManager = new token_bucket_manager_1.TokenBucketManager(db);
+                    return [4 /*yield*/, tokenBucketManager.initialize()];
+                case 2:
+                    _a.sent();
+                    log.info(tag, '✅ TokenBucketManager initialized');
+                    // Schedule daily refill at midnight UTC
+                    (0, refill_scheduler_1.scheduleDailyRefill)(tokenBucketManager, metricsLogger);
+                    log.info(tag, '✅ Daily refill scheduler started');
+                    log.info(tag, '🎉 Token bucket system fully initialized!');
+                    return [3 /*break*/, 5];
+                case 3:
+                    error_12 = _a.sent();
+                    log.error(tag, 'Failed to initialize token buckets:', error_12);
+                    return [3 /*break*/, 5];
+                case 4:
+                    isInitializing = false;
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Call on module load (with delay to ensure MongoDB is ready)
+setTimeout(function () {
+    initializeTokenBuckets().catch(function (err) {
+        log.error(TAG, 'Token bucket initialization failed:', err);
+    });
+}, 5000); // 5 second delay to let MongoDB connect