pmxt-core 2.4.0 → 2.5.0

package/dist/exchanges/myriad/index.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyriadExchange = void 0;
+const axios_1 = __importDefault(require("axios"));
+const BaseExchange_1 = require("../../BaseExchange");
+const fetchMarkets_1 = require("./fetchMarkets");
+const fetchEvents_1 = require("./fetchEvents");
+const fetchOHLCV_1 = require("./fetchOHLCV");
+const fetchOrderBook_1 = require("./fetchOrderBook");
+const fetchTrades_1 = require("./fetchTrades");
+const auth_1 = require("./auth");
+const websocket_1 = require("./websocket");
+const errors_1 = require("./errors");
+const errors_2 = require("../../errors");
+const utils_1 = require("./utils");
+class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
+    auth;
+    ws;
+    constructor(credentials) {
+        super(credentials);
+        if (credentials?.apiKey) {
+            this.auth = new auth_1.MyriadAuth(credentials);
+        }
+    }
+    get name() {
+        return 'Myriad';
+    }
+    getHeaders() {
+        if (this.auth) {
+            return this.auth.getHeaders();
+        }
+        return { 'Content-Type': 'application/json' };
+    }
+    ensureAuth() {
+        if (!this.auth) {
+            throw new errors_2.AuthenticationError('This operation requires authentication. Initialize MyriadExchange with credentials (apiKey).', 'Myriad');
+        }
+        return this.auth;
+    }
+    // ------------------------------------------------------------------------
+    // Market Data
+    // ------------------------------------------------------------------------
+    async fetchMarketsImpl(params) {
+        return (0, fetchMarkets_1.fetchMarkets)(params, this.getHeaders());
+    }
+    async fetchEventsImpl(params) {
+        return (0, fetchEvents_1.fetchEvents)(params, this.getHeaders());
+    }
+    async fetchOHLCV(id, params) {
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.getHeaders());
+    }
+    async fetchOrderBook(id) {
+        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.getHeaders());
+    }
+    async fetchTrades(id, params) {
+        if ('resolution' in params && params.resolution !== undefined) {
+            console.warn('[pmxt] Warning: The "resolution" parameter is deprecated for fetchTrades() and will be ignored. ' +
+                'It will be removed in v3.0.0. Please remove it from your code.');
+        }
+        return (0, fetchTrades_1.fetchTrades)(id, params, this.getHeaders());
+    }
+    // ------------------------------------------------------------------------
+    // Trading
+    // ------------------------------------------------------------------------
+    async createOrder(params) {
+        try {
+            const auth = this.ensureAuth();
+            const headers = auth.getHeaders();
+            // Parse composite marketId: {networkId}:{marketId}
+            const parts = params.marketId.split(':');
+            if (parts.length < 2) {
+                throw new Error(`Invalid marketId format: "${params.marketId}". Expected "{networkId}:{marketId}".`);
+            }
+            const [networkId, marketId] = parts;
+            // Parse outcomeId: {networkId}:{marketId}:{outcomeId}
+            const outcomeParts = params.outcomeId.split(':');
+            const outcomeId = outcomeParts.length >= 3 ? Number(outcomeParts[2]) : Number(outcomeParts[0]);
+            const quoteBody = {
+                market_id: Number(marketId),
+                outcome_id: outcomeId,
+                network_id: Number(networkId),
+                action: params.side,
+            };
+            if (params.side === 'buy') {
+                quoteBody.value = params.amount;
+            }
+            else {
+                quoteBody.shares = params.amount;
+            }
+            if (params.price) {
+                // Use price as slippage tolerance for AMM
+                quoteBody.slippage = 0.01;
+            }
+            const response = await axios_1.default.post(`${utils_1.BASE_URL}/markets/quote`, quoteBody, { headers });
+            const quote = response.data;
+            return {
+                id: `myriad-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                marketId: params.marketId,
+                outcomeId: params.outcomeId,
+                side: params.side,
+                type: 'market', // AMM only supports market orders
+                price: quote.price_average,
+                amount: params.side === 'buy' ? quote.value : quote.shares,
+                status: 'pending',
+                filled: 0,
+                remaining: params.side === 'buy' ? quote.value : quote.shares,
+                timestamp: Date.now(),
+                fee: quote.fees ? (quote.fees.fee + quote.fees.treasury + quote.fees.distributor) : undefined,
+            };
+        }
+        catch (error) {
+            throw errors_1.myriadErrorMapper.mapError(error);
+        }
+    }
+    async cancelOrder(_orderId) {
+        throw new Error('cancelOrder() is not supported by Myriad (AMM-based exchange, no open orders)');
+    }
+    async fetchOrder(_orderId) {
+        throw new Error('fetchOrder() is not supported by Myriad (AMM-based exchange)');
+    }
+    async fetchOpenOrders(_marketId) {
+        return []; // AMM: no open orders
+    }
+    async fetchPositions() {
+        try {
+            const auth = this.ensureAuth();
+            const headers = auth.getHeaders();
+            const walletAddress = auth.walletAddress;
+            if (!walletAddress) {
+                throw new errors_2.AuthenticationError('fetchPositions requires a wallet address. Pass privateKey as the wallet address in credentials.', 'Myriad');
+            }
+            const response = await axios_1.default.get(`${utils_1.BASE_URL}/users/${walletAddress}/portfolio`, {
+                params: { limit: 100 },
+                headers,
+            });
+            const items = response.data.data || response.data.items || [];
+            return items.map((pos) => ({
+                marketId: `${pos.networkId}:${pos.marketId}`,
+                outcomeId: `${pos.networkId}:${pos.marketId}:${pos.outcomeId}`,
+                outcomeLabel: pos.outcomeTitle || `Outcome ${pos.outcomeId}`,
+                size: Number(pos.shares || 0),
+                entryPrice: Number(pos.price || 0),
+                currentPrice: Number(pos.value || 0) / Math.max(Number(pos.shares || 1), 1),
+                unrealizedPnL: Number(pos.profit || 0),
+            }));
+        }
+        catch (error) {
+            throw errors_1.myriadErrorMapper.mapError(error);
+        }
+    }
+    async fetchBalance() {
+        // Myriad is on-chain; balances are per-chain token balances.
+        // The API doesn't expose a balance endpoint directly.
+        // We approximate from portfolio positions.
+        try {
+            const auth = this.ensureAuth();
+            const headers = auth.getHeaders();
+            const walletAddress = auth.walletAddress;
+            if (!walletAddress) {
+                throw new errors_2.AuthenticationError('fetchBalance requires a wallet address. Pass privateKey as the wallet address in credentials.', 'Myriad');
+            }
+            const response = await axios_1.default.get(`${utils_1.BASE_URL}/users/${walletAddress}/portfolio`, {
+                params: { limit: 100 },
+                headers,
+            });
+            const items = response.data.data || response.data.items || [];
+            let totalValue = 0;
+            for (const pos of items) {
+                totalValue += Number(pos.value || 0);
+            }
+            return [{
+                    currency: 'USDC',
+                    total: totalValue,
+                    available: 0, // Cannot determine on-chain balance via API
+                    locked: totalValue,
+                }];
+        }
+        catch (error) {
+            throw errors_1.myriadErrorMapper.mapError(error);
+        }
+    }
+    // ------------------------------------------------------------------------
+    // WebSocket (poll-based)
+    // ------------------------------------------------------------------------
+    async watchOrderBook(id, _limit) {
+        this.ensureAuth();
+        if (!this.ws) {
+            this.ws = new websocket_1.MyriadWebSocket(this.getHeaders());
+        }
+        return this.ws.watchOrderBook(id);
+    }
+    async watchTrades(id, _since, _limit) {
+        this.ensureAuth();
+        if (!this.ws) {
+            this.ws = new websocket_1.MyriadWebSocket(this.getHeaders());
+        }
+        return this.ws.watchTrades(id);
+    }
+    async close() {
+        if (this.ws) {
+            await this.ws.close();
+            this.ws = undefined;
+        }
+    }
+}
+exports.MyriadExchange = MyriadExchange;

package/dist/exchanges/myriad/utils.d.ts

@@ -0,0 +1,15 @@
+import { UnifiedMarket, UnifiedEvent } from '../../types';
+export declare const BASE_URL = "https://api-v2.myriadprotocol.com";
+export declare const NETWORKS: {
+    readonly ABSTRACT: 2741;
+    readonly LINEA: 59144;
+    readonly BNB: 56;
+};
+export declare const CONTRACTS: Record<number, {
+    predictionMarket: string;
+    querier: string;
+}>;
+export declare function mapMarketState(state: string): 'active' | 'inactive' | 'closed';
+export declare function mapStatusToMyriad(status?: string): string | undefined;
+export declare function mapMarketToUnified(market: any): UnifiedMarket | null;
+export declare function mapQuestionToEvent(question: any): UnifiedEvent | null;

package/dist/exchanges/myriad/utils.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRACTS = exports.NETWORKS = exports.BASE_URL = void 0;
+exports.mapMarketState = mapMarketState;
+exports.mapStatusToMyriad = mapStatusToMyriad;
+exports.mapMarketToUnified = mapMarketToUnified;
+exports.mapQuestionToEvent = mapQuestionToEvent;
+const market_utils_1 = require("../../utils/market-utils");
+exports.BASE_URL = 'https://api-v2.myriadprotocol.com';
+// Mainnet network IDs
+exports.NETWORKS = {
+    ABSTRACT: 2741,
+    LINEA: 59144,
+    BNB: 56,
+};
+// Mainnet contract addresses
+exports.CONTRACTS = {
+    [exports.NETWORKS.ABSTRACT]: {
+        predictionMarket: '0x3e0F5F8F5Fb043aBFA475C0308417Bf72c463289',
+        querier: '0x1d5773Cd0dC74744C1F7a19afEeECfFE64f233Ff',
+    },
+    [exports.NETWORKS.LINEA]: {
+        predictionMarket: '0x39e66ee6b2ddaf4defded3038e0162180dbef340',
+        querier: '0x503c9f98398dc3433ABa819BF3eC0b97e02B8D04',
+    },
+    [exports.NETWORKS.BNB]: {
+        predictionMarket: '0x39E66eE6b2ddaf4DEfDEd3038E0162180dbeF340',
+        querier: '0xDeFb36c47754D2e37d44b8b8C647D4D643e03bAd',
+    },
+};
+function mapMarketState(state) {
+    switch (state) {
+        case 'open':
+            return 'active';
+        case 'closed':
+            return 'inactive';
+        case 'resolved':
+            return 'closed';
+        default:
+            return 'active';
+    }
+}
+function mapStatusToMyriad(status) {
+    if (!status)
+        return undefined;
+    switch (status) {
+        case 'active':
+            return 'open';
+        case 'inactive':
+        case 'closed':
+            return 'closed';
+        default:
+            return undefined;
+    }
+}
+function mapMarketToUnified(market) {
+    if (!market)
+        return null;
+    const outcomes = (market.outcomes || []).map((o) => ({
+        outcomeId: `${market.networkId}:${market.id}:${o.id}`,
+        marketId: `${market.networkId}:${market.id}`,
+        label: o.title || `Outcome ${o.id}`,
+        price: Number(o.price) || 0,
+        priceChange24h: o.priceChange24h != null ? Number(o.priceChange24h) : undefined,
+    }));
+    const um = {
+        marketId: `${market.networkId}:${market.id}`,
+        title: market.title || '',
+        description: market.description || '',
+        outcomes,
+        resolutionDate: market.expiresAt ? new Date(market.expiresAt) : new Date(0),
+        volume24h: Number(market.volume24h || 0),
+        volume: Number(market.volume || 0),
+        liquidity: Number(market.liquidity || 0),
+        url: `https://myriad.markets/markets/${market.slug || market.id}`,
+        image: market.imageUrl,
+        tags: market.topics || [],
+    };
+    (0, market_utils_1.addBinaryOutcomes)(um);
+    return um;
+}
+function mapQuestionToEvent(question) {
+    if (!question)
+        return null;
+    const markets = [];
+    for (const m of question.markets || []) {
+        const um = mapMarketToUnified(m);
+        if (um)
+            markets.push(um);
+    }
+    return {
+        id: String(question.id),
+        title: question.title || '',
+        description: '',
+        slug: String(question.id),
+        markets,
+        url: `https://myriad.markets`,
+    };
+}

package/dist/exchanges/myriad/websocket.d.ts

@@ -0,0 +1,17 @@
+import { OrderBook, Trade } from '../../types';
+export declare class MyriadWebSocket {
+    private headers;
+    private pollInterval;
+    private orderBookTimers;
+    private tradeTimers;
+    private orderBookResolvers;
+    private tradeResolvers;
+    private lastTradeTimestamp;
+    private closed;
+    constructor(headers: Record<string, string>, pollInterval?: number);
+    watchOrderBook(id: string): Promise<OrderBook>;
+    watchTrades(id: string): Promise<Trade[]>;
+    close(): Promise<void>;
+    private startOrderBookPolling;
+    private startTradePolling;
+}

package/dist/exchanges/myriad/websocket.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyriadWebSocket = void 0;
+const fetchOrderBook_1 = require("./fetchOrderBook");
+const fetchTrades_1 = require("./fetchTrades");
+// Myriad API v2 does not expose a WebSocket endpoint.
+// We implement a poll-based fallback that resolves promises
+// on each polling interval, matching the CCXT Pro async pattern.
+const DEFAULT_POLL_INTERVAL = 5000; // 5 seconds
+class MyriadWebSocket {
+    headers;
+    pollInterval;
+    orderBookTimers = new Map();
+    tradeTimers = new Map();
+    orderBookResolvers = new Map();
+    tradeResolvers = new Map();
+    lastTradeTimestamp = new Map();
+    closed = false;
+    constructor(headers, pollInterval) {
+        this.headers = headers;
+        this.pollInterval = pollInterval || DEFAULT_POLL_INTERVAL;
+    }
+    async watchOrderBook(id) {
+        if (this.closed)
+            throw new Error('WebSocket connection is closed');
+        return new Promise((resolve) => {
+            if (!this.orderBookResolvers.has(id)) {
+                this.orderBookResolvers.set(id, []);
+            }
+            this.orderBookResolvers.get(id).push(resolve);
+            if (!this.orderBookTimers.has(id)) {
+                this.startOrderBookPolling(id);
+            }
+        });
+    }
+    async watchTrades(id) {
+        if (this.closed)
+            throw new Error('WebSocket connection is closed');
+        return new Promise((resolve) => {
+            if (!this.tradeResolvers.has(id)) {
+                this.tradeResolvers.set(id, []);
+            }
+            this.tradeResolvers.get(id).push(resolve);
+            if (!this.tradeTimers.has(id)) {
+                this.startTradePolling(id);
+            }
+        });
+    }
+    async close() {
+        this.closed = true;
+        for (const timer of this.orderBookTimers.values()) {
+            clearInterval(timer);
+        }
+        for (const timer of this.tradeTimers.values()) {
+            clearInterval(timer);
+        }
+        this.orderBookTimers.clear();
+        this.tradeTimers.clear();
+        this.orderBookResolvers.clear();
+        this.tradeResolvers.clear();
+    }
+    startOrderBookPolling(id) {
+        const poll = async () => {
+            try {
+                const book = await (0, fetchOrderBook_1.fetchOrderBook)(id, this.headers);
+                const resolvers = this.orderBookResolvers.get(id) || [];
+                this.orderBookResolvers.set(id, []);
+                for (const resolve of resolvers) {
+                    resolve(book);
+                }
+            }
+            catch {
+                // Silently retry on next interval
+            }
+        };
+        // Immediate first poll
+        poll();
+        const timer = setInterval(poll, this.pollInterval);
+        this.orderBookTimers.set(id, timer);
+    }
+    startTradePolling(id) {
+        const poll = async () => {
+            try {
+                const since = this.lastTradeTimestamp.get(id);
+                const trades = await (0, fetchTrades_1.fetchTrades)(id, { limit: 50, start: since ? new Date(since) : undefined }, this.headers);
+                if (trades.length > 0) {
+                    const maxTs = Math.max(...trades.map(t => t.timestamp));
+                    this.lastTradeTimestamp.set(id, maxTs + 1);
+                }
+                const resolvers = this.tradeResolvers.get(id) || [];
+                this.tradeResolvers.set(id, []);
+                for (const resolve of resolvers) {
+                    resolve(trades);
+                }
+            }
+            catch {
+                // Silently retry on next interval
+            }
+        };
+        poll();
+        const timer = setInterval(poll, this.pollInterval);
+        this.tradeTimers.set(id, timer);
+    }
+}
+exports.MyriadWebSocket = MyriadWebSocket;

package/dist/exchanges/polymarket/fetchEvents.js

@@ -1,14 +1,83 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchEvents = fetchEvents;
+const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
+async function fetchEventByGammaId(id) {
+    const response = await axios_1.default.get(utils_1.GAMMA_API_URL, {
+        params: { id }
+    });
+    const events = response.data;
+    if (!events || events.length === 0)
+        return [];
+    return events.map((event) => {
+        const markets = [];
+        if (event.markets && Array.isArray(event.markets)) {
+            for (const market of event.markets) {
+                const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
+                if (unifiedMarket) {
+                    markets.push(unifiedMarket);
+                }
+            }
+        }
+        return {
+            id: event.id || event.slug,
+            title: event.title,
+            description: event.description || '',
+            slug: event.slug,
+            markets,
+            url: `https://polymarket.com/event/${event.slug}`,
+            image: event.image || `https://polymarket.com/api/og?slug=${event.slug}`,
+            category: event.category || event.tags?.[0]?.label,
+            tags: event.tags?.map((t) => t.label) || []
+        };
+    });
+}
+async function fetchEventBySlug(slug) {
+    const response = await axios_1.default.get(utils_1.GAMMA_API_URL, {
+        params: { slug }
+    });
+    const events = response.data;
+    if (!events || events.length === 0)
+        return [];
+    return events.map((event) => {
+        const markets = [];
+        if (event.markets && Array.isArray(event.markets)) {
+            for (const market of event.markets) {
+                const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
+                if (unifiedMarket) {
+                    markets.push(unifiedMarket);
+                }
+            }
+        }
+        return {
+            id: event.id || event.slug,
+            title: event.title,
+            description: event.description || '',
+            slug: event.slug,
+            markets,
+            url: `https://polymarket.com/event/${event.slug}`,
+            image: event.image || `https://polymarket.com/api/og?slug=${event.slug}`,
+            category: event.category || event.tags?.[0]?.label,
+            tags: event.tags?.map((t) => t.label) || []
+        };
+    });
+}
 async function fetchEvents(params) {
     try {
+        // Handle eventId lookup (Gamma event ID)
+        if (params.eventId) {
+            return await fetchEventByGammaId(params.eventId);
+        }
+        // Handle slug lookup
+        if (params.slug) {
+            return await fetchEventBySlug(params.slug);
+        }
         if (!params.query) {
-            // If no query is provided, we can't use the search endpoint effectively.
-            // However, the BaseExchange interface enforces query presence for fetchEvents.
-            // Just in case, we return empty or throw.
             throw new Error("Query is required for Polymarket event search");
         }
         const limit = params.limit || 10000;

package/dist/exchanges/polymarket/fetchMarkets.js

@@ -9,10 +9,23 @@ const utils_1 = require("./utils");
 const errors_1 = require("./errors");
 async function fetchMarkets(params) {
     try {
+        // Handle marketId lookup (Gamma market condition ID)
+        if (params?.marketId) {
+            return await fetchMarketById(params.marketId);
+        }
         // Handle slug-based lookup
         if (params?.slug) {
             return await fetchMarketsBySlug(params.slug);
         }
+        // Handle outcomeId lookup (CLOB token ID -- no direct API, fetch and filter)
+        if (params?.outcomeId) {
+            const markets = await fetchMarketsDefault(params);
+            return markets.filter(m => m.outcomes.some(o => o.outcomeId === params.outcomeId));
+        }
+        // Handle eventId lookup (Gamma event ID)
+        if (params?.eventId) {
+            return await fetchMarketsByEventId(params.eventId);
+        }
         // Handle query-based search
         if (params?.query) {
             return await searchMarkets(params.query, params);
@@ -24,6 +37,45 @@ async function fetchMarkets(params) {
         throw errors_1.polymarketErrorMapper.mapError(error);
     }
 }
+async function fetchMarketById(marketId) {
+    const GAMMA_MARKETS_URL = 'https://gamma-api.polymarket.com/markets';
+    const response = await axios_1.default.get(GAMMA_MARKETS_URL, {
+        params: { id: marketId }
+    });
+    const markets = response.data;
+    if (!markets || markets.length === 0)
+        return [];
+    const unifiedMarkets = [];
+    for (const market of markets) {
+        // The /markets endpoint returns markets with an embedded 'events' array
+        const event = market.events?.[0] || market;
+        const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
+        if (unifiedMarket) {
+            unifiedMarkets.push(unifiedMarket);
+        }
+    }
+    return unifiedMarkets;
+}
+async function fetchMarketsByEventId(eventId) {
+    const response = await axios_1.default.get(utils_1.GAMMA_API_URL, {
+        params: { id: eventId }
+    });
+    const events = response.data;
+    if (!events || events.length === 0)
+        return [];
+    const unifiedMarkets = [];
+    for (const event of events) {
+        if (!event.markets)
+            continue;
+        for (const market of event.markets) {
+            const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
+            if (unifiedMarket) {
+                unifiedMarkets.push(unifiedMarket);
+            }
+        }
+    }
+    return unifiedMarkets;
+}
 async function fetchMarketsBySlug(slug) {
     const response = await axios_1.default.get(utils_1.GAMMA_API_URL, {
         params: { slug: slug }

package/dist/exchanges/probable/fetchEvents.js

@@ -11,6 +11,16 @@ const utils_1 = require("./utils");
 const errors_1 = require("./errors");
 async function fetchEvents(params) {
     try {
+        // Handle eventId lookup
+        if (params.eventId) {
+            const event = await fetchEventById(params.eventId);
+            return event ? [event] : [];
+        }
+        // Handle slug lookup
+        if (params.slug) {
+            const event = await fetchEventBySlug(params.slug);
+            return event ? [event] : [];
+        }
         // Query-based search: use the search endpoint (only endpoint with text search)
         if (params.query) {
             return await searchEvents(params);

package/dist/exchanges/probable/fetchMarkets.js

@@ -9,10 +9,23 @@ const utils_1 = require("./utils");
 const errors_1 = require("./errors");
 async function fetchMarkets(params) {
     try {
+        // Handle marketId lookup (numeric ID or slug)
+        if (params?.marketId) {
+            return await fetchMarketByIdOrSlug(params.marketId);
+        }
         // Slug-based lookup: try market ID or slug via dedicated endpoint
         if (params?.slug) {
             return await fetchMarketByIdOrSlug(params.slug);
         }
+        // Handle outcomeId lookup (no direct API, fetch and filter client-side)
+        if (params?.outcomeId) {
+            const markets = await fetchMarketsList(params);
+            return markets.filter(m => m.outcomes.some(o => o.outcomeId === params.outcomeId));
+        }
+        // Handle eventId lookup (use markets list with eventId param)
+        if (params?.eventId) {
+            return await fetchMarketsList(params);
+        }
         // Query-based search: use the search endpoint (only endpoint with text search)
         if (params?.query) {
             return await searchAndExtractMarkets(params.query, params);
@@ -57,10 +70,16 @@ async function fetchMarketByIdOrSlug(slug) {
             return results;
         }
         catch (error) {
-            if (error.response?.status === 404) {
-                return [];
+            if (isMarketNotFoundError(error)) {
+                // Individual market endpoint returned 500/404; fall back to list and filter
+                const allMarkets = await fetchMarketsList({ limit: 100 });
+                const match = allMarkets.filter(m => m.marketId === cleanSlug);
+                if (match.length > 0)
+                    return match;
+            }
+            else {
+                throw error;
             }
-            throw error;
         }
     }
     // Fall back to search for slug-based matching
@@ -203,3 +222,14 @@ async function searchAndExtractMarkets(query, params) {
     await (0, utils_1.enrichMarketsWithPrices)(allMarkets);
     return allMarkets;
 }
+function isMarketNotFoundError(error) {
+    const status = error.response?.status;
+    if (status === 404 || status === 400)
+        return true;
+    if (status === 500) {
+        const data = error.response?.data;
+        const msg = typeof data === 'string' ? data : (data?.detail || data?.message || '');
+        return /not found|failed to retrieve/i.test(String(msg));
+    }
+    return false;
+}