pmxt-core 2.20.0 → 2.20.2

package/dist/exchanges/limitless/index.js

@@ -13,11 +13,8 @@ const api_1 = require("./api");
 const auth_1 = require("./auth");
 const client_1 = require("./client");
 const errors_2 = require("./errors");
-const fetchEvents_1 = require("./fetchEvents");
-const fetchMarkets_1 = require("./fetchMarkets");
-const fetchOHLCV_1 = require("./fetchOHLCV");
-const fetchOrderBook_1 = require("./fetchOrderBook");
-const fetchTrades_1 = require("./fetchTrades");
+const fetcher_1 = require("./fetcher");
+const normalizer_1 = require("./normalizer");
 const websocket_1 = require("./websocket");
 class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
@@ -46,6 +43,8 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     client;
     wsConfig;
     ws;
+    fetcher;
+    normalizer;
     constructor(options) {
         // Support both old signature (credentials only) and new signature (options object)
         let credentials;
@@ -86,27 +85,81 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         // Register implicit API for Limitless REST endpoints
         const apiDescriptor = (0, openapi_1.parseOpenApiSpec)(api_1.limitlessApiSpec);
         this.defineImplicitApi(apiDescriptor);
+        const ctx = {
+            http: this.http,
+            callApi: this.callApi.bind(this),
+            getHeaders: () => this.getHeaders(),
+        };
+        this.fetcher = new fetcher_1.LimitlessFetcher(ctx, this.http, this.auth?.getApiKey());
+        this.normalizer = new normalizer_1.LimitlessNormalizer();
     }
     get name() {
         return 'Limitless';
     }
-    // ----------------------------------------------------------------------------
-    // Implementation methods for CCXT-style API
-    // ----------------------------------------------------------------------------
+    getHeaders() {
+        return { 'Content-Type': 'application/json' };
+    }
+    // ------------------------------------------------------------------------
+    // Market Data  (fetcher -> normalizer)
+    // ------------------------------------------------------------------------
+    async fetchMarketsImpl(params) {
+        const rawMarkets = await this.fetcher.fetchRawMarkets(params);
+        // Handle outcomeId filtering (client-side)
+        if (params?.outcomeId) {
+            return rawMarkets
+                .map((raw) => this.normalizer.normalizeMarket(raw))
+                .filter((m) => m !== null && m.outcomes.length > 0)
+                .filter(m => m.outcomes.some(o => o.outcomeId === params.outcomeId));
+        }
+        // Handle search results -- filter and limit
+        if (params?.query) {
+            return rawMarkets
+                .map((raw) => this.normalizer.normalizeMarket(raw))
+                .filter((m) => m !== null && m.outcomes.length > 0)
+                .slice(0, params?.limit || 250000);
+        }
+        // Default fetch -- normalize, filter, sort, apply offset/limit
+        const unifiedMarkets = rawMarkets
+            .map((raw) => this.normalizer.normalizeMarket(raw))
+            .filter((m) => m !== null && m.outcomes.length > 0);
+        if (params?.sort === 'volume') {
+            unifiedMarkets.sort((a, b) => (b.volume ?? 0) - (a.volume ?? 0));
+        }
+        const offset = params?.offset || 0;
+        const limit = params?.limit || 250000;
+        const marketsAfterOffset = offset > 0 ? unifiedMarkets.slice(offset) : unifiedMarkets;
+        return marketsAfterOffset.slice(0, limit);
+    }
+    async fetchEventsImpl(params) {
+        const rawEvents = await this.fetcher.fetchRawEvents(params);
+        return rawEvents
+            .map((raw) => this.normalizer.normalizeEvent(raw))
+            .filter((e) => e !== null);
+    }
     async fetchOHLCV(id, params) {
-        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.callApi.bind(this));
+        const rawPrices = await this.fetcher.fetchRawOHLCV(id, params);
+        return this.normalizer.normalizeOHLCV(rawPrices, params);
     }
     async fetchOrderBook(id) {
-        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.callApi.bind(this));
+        const rawOrderBook = await this.fetcher.fetchRawOrderBook(id);
+        return this.normalizer.normalizeOrderBook(rawOrderBook, id);
     }
     async fetchTrades(id, params) {
-        // Deprecation warning
         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.http);
+        const rawTrades = await this.fetcher.fetchRawTrades(id, params);
+        return rawTrades.map((raw, i) => this.normalizer.normalizeTrade(raw, i));
     }
+    async fetchMyTrades(params) {
+        const auth = this.ensureAuth();
+        const rawTrades = await this.fetcher.fetchRawMyTrades(params || {}, auth.getApiKey());
+        return rawTrades.map((raw, i) => this.normalizer.normalizeUserTrade(raw, i));
+    }
+    // ------------------------------------------------------------------------
+    // Trading  (kept in SDK class -- uses LimitlessClient)
+    // ------------------------------------------------------------------------
     async createOrder(params) {
         const client = this.ensureClient();
         try {
@@ -147,9 +200,6 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             throw errors_2.limitlessErrorMapper.mapError(error);
         }
     }
-    // ----------------------------------------------------------------------------
-    // Trading Methods
-    // ----------------------------------------------------------------------------
     async cancelOrder(orderId) {
         const client = this.ensureClient();
         try {
@@ -172,18 +222,12 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         }
     }
     async fetchOrder(orderId) {
-        // Limitless API does not support fetching a single order by ID directly without the market slug.
-        // We would need to scan all markets or maintain a local cache.
-        // For now, we throw specific error.
         throw new Error('Limitless: fetchOrder(id) is not supported directly. Use fetchOpenOrders(marketSlug).');
     }
     async fetchOpenOrders(marketId) {
         const client = this.ensureClient();
         try {
             if (!marketId) {
-                // We cannot fetch ALL open orders globally efficiently on Limitless (no endpoint).
-                // We would need to fetch all active markets and query each.
-                // For this MVP, we return empty or throw. Returning empty to be "compliant" with interface but logging warning.
                 console.warn('Limitless: fetchOpenOrders requires marketId (slug) to be efficient. Returning [].');
                 return [];
             }
@@ -206,26 +250,6 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             throw errors_2.limitlessErrorMapper.mapError(error);
         }
     }
-    async fetchMyTrades(params) {
-        const auth = this.ensureAuth();
-        try {
-            const response = await this.http.get('https://api.limitless.exchange/portfolio/trades', {
-                headers: { Authorization: `Bearer ${auth.getApiKey()}` },
-            });
-            const trades = Array.isArray(response.data) ? response.data : (response.data?.data || []);
-            return trades.map((t) => ({
-                id: t.id || String(t.timestamp),
-                timestamp: t.createdAt ? new Date(t.createdAt).getTime() : (t.timestamp || 0),
-                price: parseFloat(t.price || '0'),
-                amount: parseFloat(t.quantity || t.amount || '0'),
-                side: (t.side || '').toLowerCase() === 'buy' ? 'buy' : 'sell',
-                orderId: t.orderId,
-            }));
-        }
-        catch (error) {
-            throw errors_2.limitlessErrorMapper.mapError(error);
-        }
-    }
     async fetchClosedOrders(params) {
         const client = this.ensureClient();
         if (!params?.marketId) {
@@ -268,25 +292,18 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             timestamp: o.createdAt ? new Date(o.createdAt).getTime() : Date.now(),
         }));
     }
+    // ------------------------------------------------------------------------
+    // Positions & Balance  (fetcher -> normalizer)
+    // ------------------------------------------------------------------------
     async fetchPositions(address) {
-        // Public endpoint — no auth needed when an address is explicitly supplied.
+        // Public endpoint -- no auth needed when an address is explicitly supplied.
         const account = address ?? this.ensureAuth().getAddress();
-        const result = await this.callApi('PublicPortfolioController_getPositions', { account });
-        const data = result?.data || result || [];
-        return data.map((p) => ({
-            marketId: p.market?.slug || p.conditionId,
-            outcomeId: p.asset,
-            outcomeLabel: p.outcome || 'Unknown',
-            size: parseFloat(p.size || '0'),
-            entryPrice: parseFloat(p.avgPrice || '0'),
-            currentPrice: parseFloat(p.curPrice || '0'),
-            unrealizedPnL: parseFloat(p.cashPnl || '0'),
-            realizedPnL: parseFloat(p.realizedPnl || '0'),
-        }));
+        const rawItems = await this.fetcher.fetchRawPositions(account);
+        return rawItems.map((raw) => this.normalizer.normalizePosition(raw));
     }
     async fetchBalance(address) {
         try {
-            // When an external address is provided use on-chain RPC only — no auth required.
+            // When an external address is provided use on-chain RPC only -- no auth required.
             const targetAddress = address ?? this.ensureAuth().getAddress();
             return await this.getAddressOnChainBalance(targetAddress);
         }
@@ -294,10 +311,11 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             throw errors_2.limitlessErrorMapper.mapError(error);
         }
     }
+    // ------------------------------------------------------------------------
+    // WebSocket
+    // ------------------------------------------------------------------------
     async watchOrderBook(id, limit) {
         const ws = this.ensureWs();
-        // Return the snapshot immediately (this allows the script to proceed)
-        // Future versions could implement a more sophisticated queueing system
         return ws.watchOrderBook(id);
     }
     async watchTrades(id, address, since, limit) {
@@ -338,13 +356,10 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
      * exchange.watch_user_positions(callback=lambda data: print('Position update:', data))
      */
     async watchUserPositions(callback) {
-        this.ensureAuth(); // Ensure API key is available
+        this.ensureAuth();
         const ws = this.ensureWs();
         return ws.watchUserPositions(callback);
     }
-    // ----------------------------------------------------------------------------
-    // WebSocket Methods
-    // ----------------------------------------------------------------------------
     /**
      * Watch user transactions in real-time (Limitless only).
      * Requires API key authentication.
@@ -360,7 +375,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
      * exchange.watch_user_transactions(callback=lambda data: print('Transaction:', data))
      */
     async watchUserTransactions(callback) {
-        this.ensureAuth(); // Ensure API key is available
+        this.ensureAuth();
         const ws = this.ensureWs();
         return ws.watchUserTransactions(callback);
     }
@@ -404,17 +419,9 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     mapImplicitApiError(error) {
         throw errors_2.limitlessErrorMapper.mapError(error);
     }
-    // ----------------------------------------------------------------------------
-    // Implicit API Error Mapping
-    // ----------------------------------------------------------------------------
-    async fetchMarketsImpl(params) {
-        // Pass API key if available for authenticated requests
-        const apiKey = this.auth?.getApiKey();
-        return (0, fetchMarkets_1.fetchMarkets)(params, apiKey, this.callApi.bind(this));
-    }
-    async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(params, this.callApi.bind(this), this.http);
-    }
+    // ------------------------------------------------------------------------
+    // Private helpers
+    // ------------------------------------------------------------------------
     async getAddressOnChainBalance(targetAddress) {
         // Query USDC balance directly from Base chain
         const provider = new ethers_1.providers.JsonRpcProvider('https://mainnet.base.org');
@@ -439,9 +446,6 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return this.client;
     }
-    /**
-     * Ensure authentication is initialized before trading operations.
-     */
     ensureAuth() {
         if (!this.auth) {
             throw new errors_1.AuthenticationError('Trading operations require authentication. ' +
@@ -449,14 +453,12 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return this.auth;
     }
-    /**
-     * Initialize WebSocket with API key if available.
-     */
     ensureWs() {
         if (!this.ws) {
             const wsConfig = {
                 ...this.wsConfig,
                 apiKey: this.auth?.getApiKey(),
+                fetchOrderBook: (id) => this.fetchOrderBook(id),
             };
             this.ws = new websocket_1.LimitlessWebSocket(this.callApi.bind(this), wsConfig);
         }

package/dist/exchanges/limitless/normalizer.d.ts

@@ -0,0 +1,14 @@
+import { OHLCVParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Position, Balance } from '../../types';
+import { IExchangeNormalizer } from '../interfaces';
+import { LimitlessRawMarket, LimitlessRawEvent, LimitlessRawPricePoint, LimitlessRawOrderBook } from './fetcher';
+export declare class LimitlessNormalizer implements IExchangeNormalizer<LimitlessRawMarket, LimitlessRawEvent> {
+    normalizeMarket(raw: LimitlessRawMarket): UnifiedMarket | null;
+    normalizeEvent(raw: LimitlessRawEvent): UnifiedEvent | null;
+    normalizeOHLCV(rawPrices: LimitlessRawPricePoint[], params: OHLCVParams): PriceCandle[];
+    normalizeOrderBook(raw: LimitlessRawOrderBook, _id: string): OrderBook;
+    normalizeTrade(_raw: unknown, _index: number): Trade;
+    normalizeUserTrade(raw: unknown, _index: number): UserTrade;
+    normalizePosition(raw: unknown): Position;
+    normalizeBalance(raw: unknown): Balance[];
+}

package/dist/exchanges/limitless/normalizer.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitlessNormalizer = void 0;
+const utils_1 = require("./utils");
+// Limitless uses USDC with 6 decimals
+const USDC_DECIMALS = 6;
+const USDC_SCALE = Math.pow(10, USDC_DECIMALS);
+function convertSize(rawSize) {
+    return rawSize / USDC_SCALE;
+}
+class LimitlessNormalizer {
+    normalizeMarket(raw) {
+        return (0, utils_1.mapMarketToUnified)(raw);
+    }
+    normalizeEvent(raw) {
+        if (!raw)
+            return null;
+        let marketsList = [];
+        if (raw.markets && Array.isArray(raw.markets)) {
+            marketsList = raw.markets
+                .map((child) => (0, utils_1.mapMarketToUnified)(child))
+                .filter((m) => m !== null);
+        }
+        else {
+            const unifiedMarket = (0, utils_1.mapMarketToUnified)(raw);
+            if (unifiedMarket)
+                marketsList = [unifiedMarket];
+        }
+        return {
+            id: raw.slug,
+            title: raw.title || raw.question || '',
+            description: raw.description || '',
+            slug: raw.slug,
+            markets: marketsList,
+            volume24h: marketsList.reduce((sum, m) => sum + m.volume24h, 0),
+            volume: marketsList.some(m => m.volume !== undefined)
+                ? marketsList.reduce((sum, m) => sum + (m.volume ?? 0), 0)
+                : undefined,
+            url: `https://limitless.exchange/markets/${raw.slug}`,
+            image: raw.logo || `https://limitless.exchange/api/og?slug=${raw.slug}`,
+            category: raw.categories?.[0],
+            tags: raw.tags || [],
+        };
+    }
+    normalizeOHLCV(rawPrices, params) {
+        let candles = rawPrices.map((p) => {
+            const price = Number(p.price);
+            const ts = Number(p.timestamp);
+            return {
+                timestamp: ts,
+                open: price,
+                high: price,
+                low: price,
+                close: price,
+                volume: 0,
+            };
+        }).sort((a, b) => a.timestamp - b.timestamp);
+        if (params.start) {
+            candles = candles.filter((c) => c.timestamp >= params.start.getTime());
+        }
+        if (params.end) {
+            candles = candles.filter((c) => c.timestamp <= params.end.getTime());
+        }
+        if (params.limit) {
+            candles = candles.slice(0, params.limit);
+        }
+        return candles;
+    }
+    normalizeOrderBook(raw, _id) {
+        const bids = (raw.bids || []).map((level) => ({
+            price: parseFloat(String(level.price)),
+            size: convertSize(parseFloat(String(level.size))),
+        })).sort((a, b) => b.price - a.price);
+        const asks = (raw.asks || []).map((level) => ({
+            price: parseFloat(String(level.price)),
+            size: convertSize(parseFloat(String(level.size))),
+        })).sort((a, b) => a.price - b.price);
+        return {
+            bids,
+            asks,
+            timestamp: raw.timestamp || Date.now(),
+        };
+    }
+    normalizeTrade(_raw, _index) {
+        // Limitless does not have a public market trades endpoint
+        throw new Error('Limitless normalizeTrade not supported: No public market trades API available.');
+    }
+    normalizeUserTrade(raw, _index) {
+        const t = raw;
+        return {
+            id: t.id || String(t.timestamp),
+            timestamp: t.createdAt ? new Date(t.createdAt).getTime() : (t.timestamp || 0),
+            price: parseFloat(t.price || '0'),
+            amount: parseFloat(t.quantity || t.amount || '0'),
+            side: (t.side || '').toLowerCase() === 'buy' ? 'buy' : 'sell',
+            orderId: t.orderId,
+        };
+    }
+    normalizePosition(raw) {
+        const p = raw;
+        return {
+            marketId: p.market?.slug || p.conditionId,
+            outcomeId: p.asset,
+            outcomeLabel: p.outcome || 'Unknown',
+            size: parseFloat(p.size || '0'),
+            entryPrice: parseFloat(p.avgPrice || '0'),
+            currentPrice: parseFloat(p.curPrice || '0'),
+            unrealizedPnL: parseFloat(p.cashPnl || '0'),
+            realizedPnL: parseFloat(p.realizedPnl || '0'),
+        };
+    }
+    normalizeBalance(raw) {
+        // Not used in the standard flow -- balance comes from on-chain RPC
+        return [];
+    }
+}
+exports.LimitlessNormalizer = LimitlessNormalizer;

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

@@ -11,6 +11,8 @@ export interface LimitlessWebSocketConfig extends Partial<WebSocketConfig> {
     reconnectDelay?: number;
     /** Watcher subscription configurations */
     watcherConfig?: WatcherConfig;
+    /** Callback to fetch an orderbook snapshot via REST (used as fallback) */
+    fetchOrderBook?: (id: string) => Promise<OrderBook>;
 }
 /**
  * Limitless WebSocket implementation using the official SDK.
@@ -25,6 +27,7 @@ export declare class LimitlessWebSocket {
     private readonly watcher;
     private config;
     private callApi;
+    private readonly fetchOrderBookSnapshot;
     private orderbookCallbacks;
     private priceCallbacks;
     private orderbookResolvers;

package/dist/exchanges/limitless/websocket.js

@@ -4,7 +4,6 @@ exports.LimitlessWebSocket = void 0;
 const sdk_1 = require("@limitless-exchange/sdk");
 const goldsky_1 = require("../../subscriber/external/goldsky");
 const watcher_1 = require("../../subscriber/watcher");
-const fetchOrderBook_1 = require("./fetchOrderBook");
 // Limitless uses USDC with 6 decimals
 const USDC_DECIMALS = 6;
 const USDC_SCALE = Math.pow(10, USDC_DECIMALS);
@@ -27,6 +26,7 @@ class LimitlessWebSocket {
     watcher;
     config;
     callApi;
+    fetchOrderBookSnapshot;
     orderbookCallbacks = new Map();
     priceCallbacks = new Map();
     orderbookResolvers = new Map();
@@ -35,6 +35,7 @@ class LimitlessWebSocket {
     constructor(callApi, config = {}) {
         this.callApi = callApi;
         this.config = config;
+        this.fetchOrderBookSnapshot = config.fetchOrderBook ?? (async () => this.getEmptyOrderbook());
         // Initialize SDK WebSocket client
         const wsConfig = {
             url: config.url || 'wss://ws.limitless.exchange',
@@ -86,7 +87,7 @@ class LimitlessWebSocket {
         if (!this.lastOrderbookTimestamps.has(marketSlug)) {
             this.lastOrderbookTimestamps.set(marketSlug, Date.now());
             try {
-                return await (0, fetchOrderBook_1.fetchOrderBook)(marketSlug, this.callApi);
+                return await this.fetchOrderBookSnapshot(marketSlug);
             }
             catch (err) {
                 console.warn(`[LimitlessWS] Failed to fetch initial snapshot:`, err);
@@ -103,7 +104,7 @@ class LimitlessWebSocket {
         if (timeSinceLastUpdate > SNAPSHOT_REFRESH_INTERVAL) {
             this.lastOrderbookTimestamps.set(marketSlug, Date.now());
             try {
-                return await (0, fetchOrderBook_1.fetchOrderBook)(marketSlug, this.callApi);
+                return await this.fetchOrderBookSnapshot(marketSlug);
             }
             catch (err) {
                 console.warn(`[LimitlessWS] Failed to fetch refresh snapshot:`, err);
@@ -122,7 +123,7 @@ class LimitlessWebSocket {
                     // Timeout: fetch REST snapshot as fallback
                     try {
                         this.lastOrderbookTimestamps.set(marketSlug, Date.now());
-                        const snapshot = await (0, fetchOrderBook_1.fetchOrderBook)(marketSlug, this.callApi);
+                        const snapshot = await this.fetchOrderBookSnapshot(marketSlug);
                         resolve(snapshot);
                     }
                     catch (err) {

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-03-14T16:22:11.436Z
+ * Generated at: 2026-03-14T21:28:31.889Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const myriadApiSpec: {

package/dist/exchanges/myriad/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.myriadApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-03-14T16:22:11.436Z
+ * Generated at: 2026-03-14T21:28:31.889Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.myriadApiSpec = {

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

@@ -0,0 +1,73 @@
+import { MarketFilterParams, EventFetchParams, OHLCVParams, TradesParams, MyTradesParams } from '../../BaseExchange';
+import { IExchangeFetcher, FetcherContext } from '../interfaces';
+export interface MyriadRawMarket {
+    id: number;
+    networkId: number;
+    title?: string;
+    description?: string;
+    slug?: string;
+    imageUrl?: string;
+    expiresAt?: string;
+    volume24h?: number;
+    volume?: number;
+    liquidity?: number;
+    questionId?: number;
+    topics?: string[];
+    outcomes?: MyriadRawOutcome[];
+    [key: string]: unknown;
+}
+export interface MyriadRawOutcome {
+    id: number;
+    title?: string;
+    price?: number;
+    priceChange24h?: number;
+    price_charts?: Record<string, {
+        timeframe: string;
+        prices: {
+            value: number;
+            timestamp: number;
+        }[];
+    }>;
+    [key: string]: unknown;
+}
+export interface MyriadRawQuestion {
+    id: number;
+    title?: string;
+    markets?: MyriadRawMarket[];
+    [key: string]: unknown;
+}
+export interface MyriadRawTradeEvent {
+    action?: string;
+    blockNumber?: number;
+    timestamp?: number;
+    value?: number;
+    shares?: number;
+    outcomeId?: number;
+    [key: string]: unknown;
+}
+export interface MyriadRawPortfolioItem {
+    networkId: number;
+    marketId: number;
+    outcomeId: number;
+    outcomeTitle?: string;
+    shares?: number;
+    price?: number;
+    profit?: number;
+    value?: number;
+    [key: string]: unknown;
+}
+export declare class MyriadFetcher implements IExchangeFetcher<MyriadRawMarket, MyriadRawQuestion> {
+    private readonly ctx;
+    constructor(ctx: FetcherContext);
+    fetchRawMarkets(params?: MarketFilterParams): Promise<MyriadRawMarket[]>;
+    fetchRawEvents(params: EventFetchParams): Promise<MyriadRawQuestion[]>;
+    fetchRawOHLCV(id: string, _params: OHLCVParams): Promise<MyriadRawMarket>;
+    fetchRawOrderBook(id: string): Promise<MyriadRawMarket>;
+    fetchRawTrades(id: string, params: TradesParams): Promise<MyriadRawTradeEvent[]>;
+    fetchRawMyTrades(params: MyTradesParams, walletAddress: string): Promise<MyriadRawTradeEvent[]>;
+    fetchRawPositions(walletAddress: string): Promise<MyriadRawPortfolioItem[]>;
+    fetchRawBalance(walletAddress: string): Promise<MyriadRawPortfolioItem[]>;
+    private fetchRawMarketById;
+    private fetchRawMarketBySlug;
+    private fetchRawQuestionById;
+}