pmxt-core 2.3.0 → 2.5.0

package/dist/exchanges/limitless/client.js

@@ -9,8 +9,12 @@ const LIMITLESS_API_URL = 'https://api.limitless.exchange';
  * Provides a simplified interface for market data and order operations.
  */
 class LimitlessClient {
+    httpClient;
+    orderClient;
+    marketFetcher;
+    signer;
+    marketCache = {};
     constructor(privateKey, apiKey) {
-        this.marketCache = {};
         // Fix for common .env issue where newlines are escaped
         if (privateKey.includes('\\n')) {
             privateKey = privateKey.replace(/\\n/g, '\n');

package/dist/exchanges/limitless/fetchEvents.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,8 +40,44 @@ exports.fetchEvents = fetchEvents;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
+async function fetchEventBySlug(slug) {
+    const { HttpClient, MarketFetcher } = await Promise.resolve().then(() => __importStar(require('@limitless-exchange/sdk')));
+    const httpClient = new HttpClient({ baseURL: utils_1.LIMITLESS_API_URL });
+    const marketFetcher = new MarketFetcher(httpClient);
+    const market = await marketFetcher.getMarket(slug);
+    if (!market)
+        return null;
+    let marketsList = [];
+    if (market.markets && Array.isArray(market.markets)) {
+        marketsList = market.markets
+            .map((child) => (0, utils_1.mapMarketToUnified)(child))
+            .filter((m) => m !== null);
+    }
+    else {
+        const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
+        if (unifiedMarket)
+            marketsList = [unifiedMarket];
+    }
+    return {
+        id: market.slug,
+        title: market.title || market.question,
+        description: market.description || '',
+        slug: market.slug,
+        markets: marketsList,
+        url: `https://limitless.exchange/markets/${market.slug}`,
+        image: market.logo || `https://limitless.exchange/api/og?slug=${market.slug}`,
+        category: market.categories?.[0],
+        tags: market.tags || []
+    };
+}
 async function fetchEvents(params) {
     try {
+        // Handle eventId/slug lookup (same thing for Limitless)
+        if (params.eventId || params.slug) {
+            const slug = params.eventId || params.slug;
+            const event = await fetchEventBySlug(slug);
+            return event ? [event] : [];
+        }
         // NOTE: The Limitless /markets/search endpoint currently only returns active/funded markets.
         // It does not include expired or resolved markets in search results.
         // Consequently, status 'inactive' will likely return 0 results and 'all' will only show active markets.

package/dist/exchanges/limitless/fetchMarkets.js

@@ -55,10 +55,23 @@ async function fetchMarkets(params, apiKey) {
             apiKey: apiKey, // Optional - not required for public market data
         });
         const marketFetcher = new MarketFetcher(httpClient);
+        // Handle marketId lookup (Limitless marketId is the slug)
+        if (params?.marketId) {
+            return await fetchMarketsBySlug(marketFetcher, params.marketId);
+        }
         // Handle slug-based lookup
         if (params?.slug) {
             return await fetchMarketsBySlug(marketFetcher, params.slug);
         }
+        // Handle outcomeId lookup (no direct API, fetch and filter client-side)
+        if (params?.outcomeId) {
+            const markets = await fetchMarketsDefault(marketFetcher, params);
+            return markets.filter(m => m.outcomes.some(o => o.outcomeId === params.outcomeId));
+        }
+        // Handle eventId lookup (same as slug for Limitless)
+        if (params?.eventId) {
+            return await fetchMarketsBySlug(marketFetcher, params.eventId);
+        }
         // Handle query-based search
         if (params?.query) {
             return await searchMarkets(marketFetcher, params.query, params);

package/dist/exchanges/limitless/index.js

@@ -16,6 +16,9 @@ const errors_2 = require("../../errors");
 const sdk_1 = require("@limitless-exchange/sdk");
 const ethers_1 = require("ethers");
 class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
+    auth;
+    client;
+    wsConfig;
     constructor(options) {
         // Support both old signature (credentials only) and new signature (options object)
         let credentials;
@@ -112,7 +115,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
                 throw new Error('Limit orders require a price');
             }
             // Limitless (USDC on Base) supports 6 decimals max.
-            const price = Math.round(params.price * 1000000) / 1000000;
+            const price = Math.round(params.price * 1_000_000) / 1_000_000;
             const response = await client.createOrder({
                 marketSlug: marketSlug,
                 outcomeId: params.outcomeId,
@@ -231,6 +234,10 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             throw errors_1.limitlessErrorMapper.mapError(error);
         }
     }
+    // ----------------------------------------------------------------------------
+    // WebSocket Methods
+    // ----------------------------------------------------------------------------
+    ws;
     /**
      * Initialize WebSocket with API key if available.
      */

package/dist/exchanges/limitless/websocket.js

@@ -21,12 +21,14 @@ function convertSize(rawSize) {
  * - User transactions (requires API key)
  */
 class LimitlessWebSocket {
+    client;
+    config;
+    orderbookCallbacks = new Map();
+    priceCallbacks = new Map();
+    orderbookResolvers = new Map();
+    orderbookBuffers = new Map();
+    lastOrderbookTimestamps = new Map();
     constructor(config = {}) {
-        this.orderbookCallbacks = new Map();
-        this.priceCallbacks = new Map();
-        this.orderbookResolvers = new Map();
-        this.orderbookBuffers = new Map();
-        this.lastOrderbookTimestamps = new Map();
         this.config = config;
         // Initialize SDK WebSocket client
         const wsConfig = {

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

@@ -0,0 +1,8 @@
+import { ExchangeCredentials } from '../../BaseExchange';
+export declare class MyriadAuth {
+    private credentials;
+    constructor(credentials: ExchangeCredentials);
+    private validateCredentials;
+    getHeaders(): Record<string, string>;
+    get walletAddress(): string | undefined;
+}

package/dist/exchanges/myriad/auth.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyriadAuth = void 0;
+class MyriadAuth {
+    credentials;
+    constructor(credentials) {
+        this.credentials = credentials;
+        this.validateCredentials();
+    }
+    validateCredentials() {
+        if (!this.credentials.apiKey) {
+            throw new Error('Myriad requires an apiKey for authentication');
+        }
+    }
+    getHeaders() {
+        return {
+            'x-api-key': this.credentials.apiKey,
+            'Content-Type': 'application/json',
+        };
+    }
+    get walletAddress() {
+        return this.credentials.privateKey;
+    }
+}
+exports.MyriadAuth = MyriadAuth;

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

@@ -0,0 +1,8 @@
+import { ErrorMapper } from '../../utils/error-mapper';
+import { BadRequest } from '../../errors';
+export declare class MyriadErrorMapper extends ErrorMapper {
+    constructor();
+    protected extractErrorMessage(error: any): string;
+    protected mapBadRequestError(message: string, data: any): BadRequest;
+}
+export declare const myriadErrorMapper: MyriadErrorMapper;

package/dist/exchanges/myriad/errors.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.myriadErrorMapper = exports.MyriadErrorMapper = void 0;
+const axios_1 = __importDefault(require("axios"));
+const error_mapper_1 = require("../../utils/error-mapper");
+const errors_1 = require("../../errors");
+class MyriadErrorMapper extends error_mapper_1.ErrorMapper {
+    constructor() {
+        super('Myriad');
+    }
+    extractErrorMessage(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.data) {
+            const data = error.response.data;
+            if (data.message)
+                return data.message;
+            if (data.error && typeof data.error === 'string')
+                return data.error;
+        }
+        return super.extractErrorMessage(error);
+    }
+    mapBadRequestError(message, data) {
+        const lowerMessage = message.toLowerCase();
+        if (lowerMessage.includes('insufficient') || lowerMessage.includes('liquidity')) {
+            return new errors_1.BadRequest(message, this.exchangeName);
+        }
+        return super.mapBadRequestError(message, data);
+    }
+}
+exports.MyriadErrorMapper = MyriadErrorMapper;
+exports.myriadErrorMapper = new MyriadErrorMapper();

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

@@ -0,0 +1,3 @@
+import { EventFetchParams } from '../../BaseExchange';
+import { UnifiedEvent } from '../../types';
+export declare function fetchEvents(params: EventFetchParams, headers?: Record<string, string>): Promise<UnifiedEvent[]>;

package/dist/exchanges/myriad/fetchEvents.js

@@ -0,0 +1,48 @@
+"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 fetchEvents(params, headers) {
+    try {
+        if (params.eventId) {
+            return await fetchQuestionById(params.eventId, headers);
+        }
+        if (params.slug) {
+            return await fetchQuestionById(params.slug, headers);
+        }
+        const limit = params.limit || 100;
+        const queryParams = {
+            page: 1,
+            limit: Math.min(limit, 100),
+        };
+        if (params.query) {
+            queryParams.keyword = params.query;
+        }
+        const response = await axios_1.default.get(`${utils_1.BASE_URL}/questions`, {
+            params: queryParams,
+            headers,
+        });
+        const questions = response.data.data || response.data.questions || [];
+        const events = [];
+        for (const q of questions) {
+            const event = (0, utils_1.mapQuestionToEvent)(q);
+            if (event)
+                events.push(event);
+        }
+        return events.slice(0, limit);
+    }
+    catch (error) {
+        throw errors_1.myriadErrorMapper.mapError(error);
+    }
+}
+async function fetchQuestionById(id, headers) {
+    const response = await axios_1.default.get(`${utils_1.BASE_URL}/questions/${id}`, { headers });
+    const question = response.data.data || response.data;
+    const event = (0, utils_1.mapQuestionToEvent)(question);
+    return event ? [event] : [];
+}

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

@@ -0,0 +1,3 @@
+import { MarketFetchParams } from '../../BaseExchange';
+import { UnifiedMarket } from '../../types';
+export declare function fetchMarkets(params?: MarketFetchParams, headers?: Record<string, string>): Promise<UnifiedMarket[]>;

package/dist/exchanges/myriad/fetchMarkets.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchMarkets = fetchMarkets;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+const MAX_PAGE_SIZE = 100;
+async function fetchMarkets(params, headers) {
+    try {
+        if (params?.marketId) {
+            return await fetchMarketById(params.marketId, headers);
+        }
+        if (params?.slug) {
+            return await fetchMarketBySlug(params.slug, headers);
+        }
+        const limit = params?.limit || 100;
+        const queryParams = {
+            page: params?.page || 1,
+            limit: Math.min(limit, MAX_PAGE_SIZE),
+        };
+        if (params?.query) {
+            queryParams.keyword = params.query;
+        }
+        const myriadState = (0, utils_1.mapStatusToMyriad)(params?.status);
+        if (myriadState) {
+            queryParams.state = myriadState;
+        }
+        if (params?.sort === 'volume') {
+            queryParams.sort = 'volume';
+            queryParams.order = 'desc';
+        }
+        else if (params?.sort === 'liquidity') {
+            queryParams.sort = 'liquidity';
+            queryParams.order = 'desc';
+        }
+        else if (params?.sort === 'newest') {
+            queryParams.sort = 'published_at';
+            queryParams.order = 'desc';
+        }
+        // If we need more than one page, paginate
+        if (limit <= MAX_PAGE_SIZE) {
+            const response = await axios_1.default.get(`${utils_1.BASE_URL}/markets`, {
+                params: queryParams,
+                headers,
+            });
+            const markets = response.data.data || response.data.markets || [];
+            return markets.map(utils_1.mapMarketToUnified).filter(Boolean);
+        }
+        // Paginate through multiple pages
+        const allMarkets = [];
+        let page = 1;
+        const maxPages = Math.ceil(limit / MAX_PAGE_SIZE);
+        while (page <= maxPages) {
+            queryParams.page = page;
+            queryParams.limit = MAX_PAGE_SIZE;
+            const response = await axios_1.default.get(`${utils_1.BASE_URL}/markets`, {
+                params: queryParams,
+                headers,
+            });
+            const data = response.data;
+            const markets = data.data || data.markets || [];
+            for (const m of markets) {
+                const um = (0, utils_1.mapMarketToUnified)(m);
+                if (um)
+                    allMarkets.push(um);
+            }
+            const pagination = data.pagination;
+            if (!pagination?.hasNext || markets.length === 0)
+                break;
+            page++;
+        }
+        return allMarkets.slice(0, limit);
+    }
+    catch (error) {
+        throw errors_1.myriadErrorMapper.mapError(error);
+    }
+}
+async function fetchMarketById(marketId, headers) {
+    // marketId format: {networkId}:{id}
+    const parts = marketId.split(':');
+    if (parts.length !== 2) {
+        // Try as slug
+        return fetchMarketBySlug(marketId, headers);
+    }
+    const [networkId, id] = parts;
+    const response = await axios_1.default.get(`${utils_1.BASE_URL}/markets/${id}`, {
+        params: { network_id: Number(networkId) },
+        headers,
+    });
+    const market = response.data.data || response.data;
+    const um = (0, utils_1.mapMarketToUnified)(market);
+    return um ? [um] : [];
+}
+async function fetchMarketBySlug(slug, headers) {
+    const response = await axios_1.default.get(`${utils_1.BASE_URL}/markets/${slug}`, { headers });
+    const market = response.data.data || response.data;
+    const um = (0, utils_1.mapMarketToUnified)(market);
+    return um ? [um] : [];
+}

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

@@ -0,0 +1,3 @@
+import { OHLCVParams, HistoryFilterParams } from '../../BaseExchange';
+import { PriceCandle } from '../../types';
+export declare function fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams, headers?: Record<string, string>): Promise<PriceCandle[]>;

package/dist/exchanges/myriad/fetchOHLCV.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOHLCV = fetchOHLCV;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+// Myriad provides price charts via GET /markets/:id with these timeframes:
+// - 24h: 5-minute buckets (max 288)
+// - 7d: 30-minute buckets (max 336)
+// - 30d: 4-hour buckets (max 180)
+// - all: 4-hour buckets
+function selectTimeframe(interval) {
+    switch (interval) {
+        case '1m':
+        case '5m':
+            return '24h';
+        case '15m':
+        case '1h':
+            return '7d';
+        case '6h':
+        case '1d':
+            return '30d';
+        default:
+            return '7d';
+    }
+}
+async function fetchOHLCV(id, params, headers) {
+    if (!params.resolution) {
+        throw new Error('fetchOHLCV requires a resolution parameter.');
+    }
+    try {
+        // id format: {networkId}:{marketId}:{outcomeId}
+        // We need the marketId and networkId to fetch the market, then extract the outcome's price_charts
+        const parts = id.split(':');
+        if (parts.length < 2) {
+            throw new Error(`Invalid Myriad outcome ID format: "${id}". Expected "{networkId}:{marketId}:{outcomeId}".`);
+        }
+        const networkId = parts[0];
+        const marketId = parts[1];
+        const outcomeId = parts.length >= 3 ? parts[2] : undefined;
+        const response = await axios_1.default.get(`${utils_1.BASE_URL}/markets/${marketId}`, {
+            params: { network_id: Number(networkId) },
+            headers,
+        });
+        const market = response.data.data || response.data;
+        const outcomes = market.outcomes || [];
+        // Find the target outcome
+        let targetOutcome = outcomes[0];
+        if (outcomeId !== undefined) {
+            const found = outcomes.find((o) => String(o.id) === outcomeId);
+            if (found)
+                targetOutcome = found;
+        }
+        if (!targetOutcome || !targetOutcome.price_charts) {
+            return [];
+        }
+        // price_charts is an object with numeric keys (0-3), each containing:
+        // { timeframe: '24h'|'7d'|'30d'|'all', prices: [{value, timestamp, date}] }
+        const desiredTimeframe = selectTimeframe(params.resolution);
+        const charts = targetOutcome.price_charts;
+        let prices = null;
+        for (const key of Object.keys(charts)) {
+            const chart = charts[key];
+            if (chart && chart.timeframe === desiredTimeframe && Array.isArray(chart.prices)) {
+                prices = chart.prices;
+                break;
+            }
+        }
+        if (!prices || prices.length === 0) {
+            return [];
+        }
+        const candles = prices.map((point) => ({
+            timestamp: point.timestamp ? point.timestamp * 1000 : Date.now(),
+            open: Number(point.value || 0),
+            high: Number(point.value || 0),
+            low: Number(point.value || 0),
+            close: Number(point.value || 0),
+            volume: undefined,
+        }));
+        if (params.limit && candles.length > params.limit) {
+            return candles.slice(-params.limit);
+        }
+        return candles;
+    }
+    catch (error) {
+        throw errors_1.myriadErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,2 @@
+import { OrderBook } from '../../types';
+export declare function fetchOrderBook(id: string, headers?: Record<string, string>): Promise<OrderBook>;

package/dist/exchanges/myriad/fetchOrderBook.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOrderBook = fetchOrderBook;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+// Myriad is AMM-based -- there is no native order book.
+// We synthesize a minimal order book from the current outcome price
+// and quote data to give callers a consistent interface.
+async function fetchOrderBook(id, headers) {
+    try {
+        // id format: {networkId}:{marketId}:{outcomeId}
+        const parts = id.split(':');
+        if (parts.length < 3) {
+            throw new Error(`Invalid Myriad outcome ID format: "${id}". Expected "{networkId}:{marketId}:{outcomeId}".`);
+        }
+        const [networkId, marketId, outcomeId] = parts;
+        // Fetch the market to get current prices
+        const response = await axios_1.default.get(`${utils_1.BASE_URL}/markets/${marketId}`, {
+            params: { network_id: Number(networkId) },
+            headers,
+        });
+        const market = response.data.data || response.data;
+        const outcomes = market.outcomes || [];
+        const outcome = outcomes.find((o) => String(o.id) === outcomeId) || outcomes[0];
+        if (!outcome) {
+            return { bids: [], asks: [], timestamp: Date.now() };
+        }
+        const price = Number(outcome.price) || 0.5;
+        const liquidity = Number(market.liquidity || 0);
+        // For AMM markets, we represent the current price as a single-level book.
+        // The spread is zero (AMM provides continuous liquidity at the current price).
+        // Size is derived from the market's liquidity.
+        const size = liquidity > 0 ? liquidity : 1;
+        return {
+            bids: [{ price, size }],
+            asks: [{ price, size }],
+            timestamp: Date.now(),
+        };
+    }
+    catch (error) {
+        throw errors_1.myriadErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,3 @@
+import { TradesParams, HistoryFilterParams } from '../../BaseExchange';
+import { Trade } from '../../types';
+export declare function fetchTrades(id: string, params: TradesParams | HistoryFilterParams, headers?: Record<string, string>): Promise<Trade[]>;

package/dist/exchanges/myriad/fetchTrades.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTrades = fetchTrades;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+async function fetchTrades(id, params, headers) {
+    try {
+        // id format: {networkId}:{marketId}:{outcomeId} or {networkId}:{marketId}
+        const parts = id.split(':');
+        if (parts.length < 2) {
+            throw new Error(`Invalid Myriad ID format: "${id}". Expected "{networkId}:{marketId}" or "{networkId}:{marketId}:{outcomeId}".`);
+        }
+        const [networkId, marketId] = parts;
+        const outcomeId = parts.length >= 3 ? parts[2] : undefined;
+        const queryParams = {
+            network_id: Number(networkId),
+            page: 1,
+            limit: params.limit || 100,
+        };
+        // Handle date range filters
+        const ensureDate = (d) => {
+            if (typeof d === 'string') {
+                if (!d.endsWith('Z') && !d.match(/[+-]\d{2}:\d{2}$/)) {
+                    return new Date(d + 'Z');
+                }
+                return new Date(d);
+            }
+            return d;
+        };
+        if (params.start) {
+            queryParams.since = Math.floor(ensureDate(params.start).getTime() / 1000);
+        }
+        if (params.end) {
+            queryParams.until = Math.floor(ensureDate(params.end).getTime() / 1000);
+        }
+        const response = await axios_1.default.get(`${utils_1.BASE_URL}/markets/${marketId}/events`, {
+            params: queryParams,
+            headers,
+        });
+        const events = response.data.data || response.data.events || [];
+        // Filter to buy/sell actions only (skip liquidity events)
+        const tradeEvents = events.filter((e) => e.action === 'buy' || e.action === 'sell');
+        // Filter by outcomeId if specified
+        const filtered = outcomeId
+            ? tradeEvents.filter((e) => String(e.outcomeId) === outcomeId)
+            : tradeEvents;
+        return filtered.map((t, index) => ({
+            id: `${t.blockNumber || t.timestamp}-${index}`,
+            timestamp: (t.timestamp || 0) * 1000,
+            price: t.shares > 0 ? Number(t.value) / Number(t.shares) : 0,
+            amount: Number(t.shares || 0),
+            side: t.action === 'buy' ? 'buy' : 'sell',
+        }));
+    }
+    catch (error) {
+        throw errors_1.myriadErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,24 @@
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, Balance, Order, Position, CreateOrderParams } from '../../types';
+export declare class MyriadExchange extends PredictionMarketExchange {
+    private auth?;
+    private ws?;
+    constructor(credentials?: ExchangeCredentials);
+    get name(): string;
+    private getHeaders;
+    private ensureAuth;
+    protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;
+    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    cancelOrder(_orderId: string): Promise<Order>;
+    fetchOrder(_orderId: string): Promise<Order>;
+    fetchOpenOrders(_marketId?: string): Promise<Order[]>;
+    fetchPositions(): Promise<Position[]>;
+    fetchBalance(): Promise<Balance[]>;
+    watchOrderBook(id: string, _limit?: number): Promise<OrderBook>;
+    watchTrades(id: string, _since?: number, _limit?: number): Promise<Trade[]>;
+    close(): Promise<void>;
+}