pmxt-core 2.8.0 → 2.9.0

package/dist/exchanges/myriad/fetchOHLCV.js

@@ -1,11 +1,6 @@
 "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)
@@ -27,7 +22,7 @@ function selectTimeframe(interval) {
             return '7d';
     }
 }
-async function fetchOHLCV(id, params, headers, http = axios_1.default) {
+async function fetchOHLCV(id, params, callApi) {
     if (!params.resolution) {
         throw new Error('fetchOHLCV requires a resolution parameter.');
     }
@@ -41,11 +36,8 @@ async function fetchOHLCV(id, params, headers, http = axios_1.default) {
         const networkId = parts[0];
         const marketId = parts[1];
         const outcomeId = parts.length >= 3 ? parts[2] : undefined;
-        const response = await http.get(`${utils_1.BASE_URL}/markets/${marketId}`, {
-            params: { network_id: Number(networkId) },
-            headers,
-        });
-        const market = response.data.data || response.data;
+        const response = await callApi('getMarkets', { id: marketId, network_id: Number(networkId) });
+        const market = response.data || response;
         const outcomes = market.outcomes || [];
         // Find the target outcome
         let targetOutcome = outcomes[0];

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

@@ -1,3 +1,2 @@
-import { AxiosInstance } from 'axios';
 import { OrderBook } from '../../types';
-export declare function fetchOrderBook(id: string, headers?: Record<string, string>, http?: AxiosInstance): Promise<OrderBook>;
+export declare function fetchOrderBook(id: string, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<OrderBook>;

package/dist/exchanges/myriad/fetchOrderBook.js

@@ -1,16 +1,11 @@
 "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, http = axios_1.default) {
+async function fetchOrderBook(id, callApi) {
     try {
         // id format: {networkId}:{marketId}:{outcomeId}
         const parts = id.split(':');
@@ -19,11 +14,8 @@ async function fetchOrderBook(id, headers, http = axios_1.default) {
         }
         const [networkId, marketId, outcomeId] = parts;
         // Fetch the market to get current prices
-        const response = await http.get(`${utils_1.BASE_URL}/markets/${marketId}`, {
-            params: { network_id: Number(networkId) },
-            headers,
-        });
-        const market = response.data.data || response.data;
+        const response = await callApi('getMarkets', { id: marketId, network_id: Number(networkId) });
+        const market = response.data || response;
         const outcomes = market.outcomes || [];
         const outcome = outcomes.find((o) => String(o.id) === outcomeId) || outcomes[0];
         if (!outcome) {

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

@@ -21,6 +21,8 @@ export declare class MyriadExchange extends PredictionMarketExchange {
     constructor(credentials?: ExchangeCredentials);
     get name(): string;
     private getHeaders;
+    protected sign(_method: string, _path: string, _params: Record<string, any>): Record<string, string>;
+    protected mapImplicitApiError(error: any): any;
     private ensureAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;

package/dist/exchanges/myriad/index.js

@@ -6,12 +6,13 @@ 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");
+const openapi_1 = require("../../utils/openapi");
+const api_1 = require("./api");
 class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
         fetchMarkets: true,
@@ -35,6 +36,8 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
         if (credentials?.apiKey) {
             this.auth = new auth_1.MyriadAuth(credentials);
         }
+        const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.myriadApiSpec, utils_1.BASE_URL);
+        this.defineImplicitApi(descriptor);
     }
     get name() {
         return 'Myriad';
@@ -45,6 +48,12 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return { 'Content-Type': 'application/json' };
     }
+    sign(_method, _path, _params) {
+        return this.getHeaders();
+    }
+    mapImplicitApiError(error) {
+        throw errors_1.myriadErrorMapper.mapError(error);
+    }
     ensureAuth() {
         if (!this.auth) {
             throw new errors_2.AuthenticationError('This operation requires authentication. Initialize MyriadExchange with credentials (apiKey).', 'Myriad');
@@ -61,70 +70,97 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
         return (0, fetchEvents_1.fetchEvents)(params, this.getHeaders(), this.http);
     }
     async fetchOHLCV(id, params) {
-        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.getHeaders(), this.http);
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.callApi.bind(this));
     }
     async fetchOrderBook(id) {
-        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.getHeaders(), this.http);
+        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.callApi.bind(this));
     }
     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(), this.http);
+        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 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;
+        };
+        const queryParams = {
+            id: marketId,
+            network_id: Number(networkId),
+            page: 1,
+            limit: params.limit || 100,
+        };
+        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 data = await this.callApi('getMarketsEvents', queryParams);
+        const events = data.data || data.events || [];
+        const tradeEvents = events.filter((e) => e.action === 'buy' || e.action === 'sell');
+        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',
+        }));
     }
     // ------------------------------------------------------------------------
     // 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 this.http.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,
-            };
+        // 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;
         }
-        catch (error) {
-            throw errors_1.myriadErrorMapper.mapError(error);
+        else {
+            quoteBody.shares = params.amount;
         }
+        if (params.price) {
+            quoteBody.slippage = 0.01;
+        }
+        const quote = await this.callApi('postMarketsQuote', quoteBody);
+        return {
+            id: `myriad-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            marketId: params.marketId,
+            outcomeId: params.outcomeId,
+            side: params.side,
+            type: 'market',
+            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,
+        };
     }
     async cancelOrder(_orderId) {
         throw new Error('cancelOrder() is not supported by Myriad (AMM-based exchange, no open orders)');
@@ -136,62 +172,39 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
         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 this.http.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);
+        const walletAddress = this.ensureAuth().walletAddress;
+        if (!walletAddress) {
+            throw new errors_2.AuthenticationError('fetchPositions requires a wallet address. Pass privateKey as the wallet address in credentials.', 'Myriad');
         }
+        const data = await this.callApi('getUsersPortfolio', { address: walletAddress, limit: 100 });
+        const items = data.data || 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),
+        }));
     }
     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 this.http.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,
-                }];
+        const walletAddress = this.ensureAuth().walletAddress;
+        if (!walletAddress) {
+            throw new errors_2.AuthenticationError('fetchBalance requires a wallet address. Pass privateKey as the wallet address in credentials.', 'Myriad');
         }
-        catch (error) {
-            throw errors_1.myriadErrorMapper.mapError(error);
+        const data = await this.callApi('getUsersPortfolio', { address: walletAddress, limit: 100 });
+        const items = data.data || data.items || [];
+        let totalValue = 0;
+        for (const pos of items) {
+            totalValue += Number(pos.value || 0);
         }
+        return [{
+                currency: 'USDC',
+                total: totalValue,
+                available: 0,
+                locked: totalValue,
+            }];
     }
     // ------------------------------------------------------------------------
     // WebSocket (poll-based)
@@ -199,14 +212,14 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
     async watchOrderBook(id, _limit) {
         this.ensureAuth();
         if (!this.ws) {
-            this.ws = new websocket_1.MyriadWebSocket(this.getHeaders());
+            this.ws = new websocket_1.MyriadWebSocket(this.callApi.bind(this));
         }
         return this.ws.watchOrderBook(id);
     }
     async watchTrades(id, _since, _limit) {
         this.ensureAuth();
         if (!this.ws) {
-            this.ws = new websocket_1.MyriadWebSocket(this.getHeaders());
+            this.ws = new websocket_1.MyriadWebSocket(this.callApi.bind(this));
         }
         return this.ws.watchTrades(id);
     }

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

@@ -1,6 +1,6 @@
 import { OrderBook, Trade } from '../../types';
 export declare class MyriadWebSocket {
-    private headers;
+    private callApi;
     private pollInterval;
     private orderBookTimers;
     private tradeTimers;
@@ -8,7 +8,7 @@ export declare class MyriadWebSocket {
     private tradeResolvers;
     private lastTradeTimestamp;
     private closed;
-    constructor(headers: Record<string, string>, pollInterval?: number);
+    constructor(callApi: (operationId: string, params?: Record<string, any>) => Promise<any>, pollInterval?: number);
     watchOrderBook(id: string): Promise<OrderBook>;
     watchTrades(id: string): Promise<Trade[]>;
     close(): Promise<void>;

package/dist/exchanges/myriad/websocket.js

@@ -2,13 +2,12 @@
 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;
+    callApi;
     pollInterval;
     orderBookTimers = new Map();
     tradeTimers = new Map();
@@ -16,8 +15,8 @@ class MyriadWebSocket {
     tradeResolvers = new Map();
     lastTradeTimestamp = new Map();
     closed = false;
-    constructor(headers, pollInterval) {
-        this.headers = headers;
+    constructor(callApi, pollInterval) {
+        this.callApi = callApi;
         this.pollInterval = pollInterval || DEFAULT_POLL_INTERVAL;
     }
     async watchOrderBook(id) {
@@ -62,7 +61,7 @@ class MyriadWebSocket {
     startOrderBookPolling(id) {
         const poll = async () => {
             try {
-                const book = await (0, fetchOrderBook_1.fetchOrderBook)(id, this.headers);
+                const book = await (0, fetchOrderBook_1.fetchOrderBook)(id, this.callApi);
                 const resolvers = this.orderBookResolvers.get(id) || [];
                 this.orderBookResolvers.set(id, []);
                 for (const resolve of resolvers) {
@@ -81,8 +80,31 @@ class MyriadWebSocket {
     startTradePolling(id) {
         const poll = async () => {
             try {
+                const parts = id.split(':');
+                const [networkId, marketId] = parts;
+                const outcomeId = parts.length >= 3 ? parts[2] : undefined;
                 const since = this.lastTradeTimestamp.get(id);
-                const trades = await (0, fetchTrades_1.fetchTrades)(id, { limit: 50, start: since ? new Date(since) : undefined }, this.headers);
+                const queryParams = {
+                    id: marketId,
+                    network_id: Number(networkId),
+                    page: 1,
+                    limit: 50,
+                };
+                if (since)
+                    queryParams.since = Math.floor(since / 1000);
+                const data = await this.callApi('getMarketsEvents', queryParams);
+                const events = data.data || data.events || [];
+                const tradeEvents = events.filter((e) => e.action === 'buy' || e.action === 'sell');
+                const filtered = outcomeId
+                    ? tradeEvents.filter((e) => String(e.outcomeId) === outcomeId)
+                    : tradeEvents;
+                const trades = 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',
+                }));
                 if (trades.length > 0) {
                     const maxTs = Math.max(...trades.map(t => t.timestamp));
                     this.lastTradeTimestamp.set(id, maxTs + 1);