pmxt-core 2.20.1 → 2.20.3

package/dist/exchanges/myriad/fetcher.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyriadFetcher = void 0;
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+const MAX_PAGE_SIZE = 100;
+class MyriadFetcher {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async fetchRawMarkets(params) {
+        try {
+            if (params?.marketId) {
+                return this.fetchRawMarketById(params.marketId);
+            }
+            if (params?.slug) {
+                return this.fetchRawMarketBySlug(params.slug);
+            }
+            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 (limit <= MAX_PAGE_SIZE) {
+                const response = await this.ctx.http.get(`${utils_1.BASE_URL}/markets`, {
+                    params: queryParams,
+                    headers: this.ctx.getHeaders(),
+                });
+                return response.data.data || response.data.markets || [];
+            }
+            // 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 this.ctx.http.get(`${utils_1.BASE_URL}/markets`, {
+                    params: queryParams,
+                    headers: this.ctx.getHeaders(),
+                });
+                const data = response.data;
+                const markets = data.data || data.markets || [];
+                allMarkets.push(...markets);
+                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 fetchRawEvents(params) {
+        try {
+            if (params.eventId) {
+                return this.fetchRawQuestionById(params.eventId);
+            }
+            if (params.slug) {
+                return this.fetchRawQuestionById(params.slug);
+            }
+            const limit = params.limit || 100;
+            const queryParams = {
+                page: 1,
+                limit: Math.min(limit, 100),
+            };
+            if (params.query) {
+                queryParams.keyword = params.query;
+            }
+            const response = await this.ctx.http.get(`${utils_1.BASE_URL}/questions`, {
+                params: queryParams,
+                headers: this.ctx.getHeaders(),
+            });
+            const questions = response.data.data || response.data.questions || [];
+            return questions.slice(0, limit);
+        }
+        catch (error) {
+            throw errors_1.myriadErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawOHLCV(id, _params) {
+        try {
+            const parts = id.split(':');
+            if (parts.length < 2) {
+                throw new Error(`Invalid Myriad outcome ID format: "${id}". Expected "{networkId}:{marketId}:{outcomeId}".`);
+            }
+            const [networkId, marketId] = parts;
+            const response = await this.ctx.callApi('getMarkets', { id: marketId, network_id: Number(networkId) });
+            return response.data || response;
+        }
+        catch (error) {
+            throw errors_1.myriadErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawOrderBook(id) {
+        try {
+            const parts = id.split(':');
+            if (parts.length < 3) {
+                throw new Error(`Invalid Myriad outcome ID format: "${id}". Expected "{networkId}:{marketId}:{outcomeId}".`);
+            }
+            const [networkId, marketId] = parts;
+            const response = await this.ctx.callApi('getMarkets', { id: marketId, network_id: Number(networkId) });
+            return response.data || response;
+        }
+        catch (error) {
+            throw errors_1.myriadErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawTrades(id, params) {
+        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.ctx.callApi('getMarketsEvents', queryParams);
+        const events = data.data || data.events || [];
+        const tradeEvents = events.filter((e) => e.action === 'buy' || e.action === 'sell');
+        return outcomeId
+            ? tradeEvents.filter((e) => String(e.outcomeId) === outcomeId)
+            : tradeEvents;
+    }
+    async fetchRawMyTrades(params, walletAddress) {
+        const queryParams = { address: walletAddress };
+        if (params?.marketId) {
+            const parts = params.marketId.split(':');
+            if (parts.length >= 2)
+                queryParams.market_id = parts[1];
+        }
+        if (params?.since)
+            queryParams.since = Math.floor(params.since.getTime() / 1000);
+        if (params?.until)
+            queryParams.until = Math.floor(params.until.getTime() / 1000);
+        if (params?.limit)
+            queryParams.limit = params.limit;
+        const data = await this.ctx.callApi('getUsersEvents', queryParams);
+        const events = data.data || data.events || [];
+        return events.filter((e) => e.action === 'buy' || e.action === 'sell');
+    }
+    async fetchRawPositions(walletAddress) {
+        const data = await this.ctx.callApi('getUsersPortfolio', { address: walletAddress, limit: 100 });
+        return data.data || data.items || [];
+    }
+    async fetchRawBalance(walletAddress) {
+        const data = await this.ctx.callApi('getUsersPortfolio', { address: walletAddress, limit: 100 });
+        return data.data || data.items || [];
+    }
+    // -- Private helpers -------------------------------------------------------
+    async fetchRawMarketById(marketId) {
+        const parts = marketId.split(':');
+        if (parts.length !== 2) {
+            return this.fetchRawMarketBySlug(marketId);
+        }
+        const [networkId, id] = parts;
+        const response = await this.ctx.http.get(`${utils_1.BASE_URL}/markets/${id}`, {
+            params: { network_id: Number(networkId) },
+            headers: this.ctx.getHeaders(),
+        });
+        const market = response.data.data || response.data;
+        return market ? [market] : [];
+    }
+    async fetchRawMarketBySlug(slug) {
+        const response = await this.ctx.http.get(`${utils_1.BASE_URL}/markets/${slug}`, {
+            headers: this.ctx.getHeaders(),
+        });
+        const market = response.data.data || response.data;
+        return market ? [market] : [];
+    }
+    async fetchRawQuestionById(id) {
+        const response = await this.ctx.http.get(`${utils_1.BASE_URL}/questions/${id}`, {
+            headers: this.ctx.getHeaders(),
+        });
+        const question = response.data.data || response.data;
+        return question ? [question] : [];
+    }
+}
+exports.MyriadFetcher = MyriadFetcher;

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

@@ -25,6 +25,8 @@ export declare class MyriadExchange extends PredictionMarketExchange {
     };
     private auth?;
     private ws?;
+    private readonly fetcher;
+    private readonly normalizer;
     constructor(credentials?: ExchangeCredentials);
     get name(): string;
     private getHeaders;

package/dist/exchanges/myriad/index.js

@@ -2,10 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MyriadExchange = void 0;
 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 auth_1 = require("./auth");
 const websocket_1 = require("./websocket");
 const errors_1 = require("./errors");
@@ -13,7 +9,8 @@ const errors_2 = require("../../errors");
 const utils_1 = require("./utils");
 const openapi_1 = require("../../utils/openapi");
 const api_1 = require("./api");
-const price_1 = require("./price");
+const fetcher_1 = require("./fetcher");
+const normalizer_1 = require("./normalizer");
 class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
         fetchMarkets: true,
@@ -39,6 +36,8 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
     };
     auth;
     ws;
+    fetcher;
+    normalizer;
     constructor(credentials) {
         super(credentials);
         this.rateLimit = 500;
@@ -47,6 +46,13 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.myriadApiSpec, utils_1.BASE_URL);
         this.defineImplicitApi(descriptor);
+        const ctx = {
+            http: this.http,
+            callApi: this.callApi.bind(this),
+            getHeaders: () => this.getHeaders(),
+        };
+        this.fetcher = new fetcher_1.MyriadFetcher(ctx);
+        this.normalizer = new normalizer_1.MyriadNormalizer();
     }
     get name() {
         return 'Myriad';
@@ -70,102 +76,58 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
         return this.auth;
     }
     // ------------------------------------------------------------------------
-    // Market Data
+    // Market Data  (fetcher -> normalizer)
     // ------------------------------------------------------------------------
     async fetchMarketsImpl(params) {
-        return (0, fetchMarkets_1.fetchMarkets)(params, this.getHeaders(), this.http);
+        const rawMarkets = await this.fetcher.fetchRawMarkets(params);
+        return rawMarkets
+            .map((raw) => this.normalizer.normalizeMarket(raw))
+            .filter((m) => m !== null);
     }
     async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(params, this.getHeaders(), this.http);
+        const rawQuestions = await this.fetcher.fetchRawEvents(params);
+        return rawQuestions
+            .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));
+        if (!params.resolution) {
+            throw new Error('fetchOHLCV requires a resolution parameter.');
+        }
+        const parts = id.split(':');
+        const outcomeId = parts.length >= 3 ? parts[2] : undefined;
+        const rawMarket = await this.fetcher.fetchRawOHLCV(id, params);
+        return this.normalizer.normalizeOHLCV(rawMarket, params, outcomeId);
     }
     async fetchOrderBook(id) {
-        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.callApi.bind(this));
+        const rawMarket = await this.fetcher.fetchRawOrderBook(id);
+        return this.normalizer.normalizeOrderBook(rawMarket, id);
     }
     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.');
         }
-        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: (0, price_1.resolveMyriadPrice)(t),
-            amount: Number(t.shares || 0),
-            side: t.action === 'buy' ? 'buy' : 'sell',
-        }));
+        const rawTrades = await this.fetcher.fetchRawTrades(id, params);
+        return rawTrades.map((raw, i) => this.normalizer.normalizeTrade(raw, i));
     }
     async fetchMyTrades(params) {
         const walletAddress = this.ensureAuth().walletAddress;
         if (!walletAddress) {
             throw new errors_2.AuthenticationError('fetchMyTrades requires a wallet address. Pass privateKey as the wallet address in credentials.', 'Myriad');
         }
-        const queryParams = { address: walletAddress };
-        if (params?.marketId) {
-            const parts = params.marketId.split(':');
-            if (parts.length >= 2)
-                queryParams.market_id = parts[1];
-        }
-        if (params?.since)
-            queryParams.since = Math.floor(params.since.getTime() / 1000);
-        if (params?.until)
-            queryParams.until = Math.floor(params.until.getTime() / 1000);
-        if (params?.limit)
-            queryParams.limit = params.limit;
-        const data = await this.callApi('getUsersEvents', queryParams);
-        const events = data.data || data.events || [];
-        const tradeEvents = events.filter((e) => e.action === 'buy' || e.action === 'sell');
-        return tradeEvents.map((t, i) => ({
-            id: `${t.blockNumber || t.timestamp}-${i}`,
-            timestamp: (t.timestamp || 0) * 1000,
-            price: (0, price_1.resolveMyriadPrice)(t),
-            amount: Number(t.shares || 0),
-            side: t.action === 'buy' ? 'buy' : 'sell',
-        }));
+        const rawTrades = await this.fetcher.fetchRawMyTrades(params || {}, walletAddress);
+        return rawTrades.map((raw, i) => this.normalizer.normalizeUserTrade(raw, i));
     }
     // ------------------------------------------------------------------------
-    // Trading
+    // Trading  (fetcher -> normalizer)
     // ------------------------------------------------------------------------
     async createOrder(params) {
-        // 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 = {
@@ -213,35 +175,16 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
         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: (0, price_1.resolveMyriadPrice)(pos),
-            unrealizedPnL: Number(pos.profit || 0),
-        }));
+        const rawItems = await this.fetcher.fetchRawPositions(walletAddress);
+        return rawItems.map((raw) => this.normalizer.normalizePosition(raw));
     }
     async fetchBalance() {
         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');
         }
-        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,
-            }];
+        const rawItems = await this.fetcher.fetchRawBalance(walletAddress);
+        return this.normalizer.normalizeBalance(rawItems);
     }
     // ------------------------------------------------------------------------
     // WebSocket (poll-based)
@@ -249,14 +192,14 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
     async watchOrderBook(id, _limit) {
         this.ensureAuth();
         if (!this.ws) {
-            this.ws = new websocket_1.MyriadWebSocket(this.callApi.bind(this));
+            this.ws = new websocket_1.MyriadWebSocket(this.callApi.bind(this), (id) => this.fetchOrderBook(id));
         }
         return this.ws.watchOrderBook(id);
     }
     async watchTrades(id, address, _since, _limit) {
         this.ensureAuth();
         if (!this.ws) {
-            this.ws = new websocket_1.MyriadWebSocket(this.callApi.bind(this));
+            this.ws = new websocket_1.MyriadWebSocket(this.callApi.bind(this), (id) => this.fetchOrderBook(id));
         }
         return this.ws.watchTrades(id);
     }

package/dist/exchanges/myriad/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 { MyriadRawMarket, MyriadRawQuestion, MyriadRawTradeEvent, MyriadRawPortfolioItem } from './fetcher';
+export declare class MyriadNormalizer implements IExchangeNormalizer<MyriadRawMarket, MyriadRawQuestion> {
+    normalizeMarket(raw: MyriadRawMarket): UnifiedMarket | null;
+    normalizeEvent(raw: MyriadRawQuestion): UnifiedEvent | null;
+    normalizeOHLCV(raw: MyriadRawMarket, params: OHLCVParams, outcomeId?: string): PriceCandle[];
+    normalizeOrderBook(raw: MyriadRawMarket, id: string): OrderBook;
+    normalizeTrade(raw: MyriadRawTradeEvent, index: number): Trade;
+    normalizeUserTrade(raw: MyriadRawTradeEvent, index: number): UserTrade;
+    normalizePosition(raw: MyriadRawPortfolioItem): Position;
+    normalizeBalance(rawItems: MyriadRawPortfolioItem[]): Balance[];
+}

package/dist/exchanges/myriad/normalizer.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyriadNormalizer = void 0;
+const market_utils_1 = require("../../utils/market-utils");
+const price_1 = require("./price");
+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';
+    }
+}
+class MyriadNormalizer {
+    normalizeMarket(raw) {
+        if (!raw)
+            return null;
+        const outcomes = (raw.outcomes || []).map((o) => ({
+            outcomeId: `${raw.networkId}:${raw.id}:${o.id}`,
+            marketId: `${raw.networkId}:${raw.id}`,
+            label: o.title || `Outcome ${o.id}`,
+            price: Number(o.price) || 0,
+            priceChange24h: o.priceChange24h != null ? Number(o.priceChange24h) : undefined,
+        }));
+        const um = {
+            marketId: `${raw.networkId}:${raw.id}`,
+            eventId: raw.questionId ? String(raw.questionId) : undefined,
+            title: raw.title || '',
+            description: raw.description || '',
+            outcomes,
+            resolutionDate: raw.expiresAt ? new Date(raw.expiresAt) : new Date(0),
+            volume24h: Number(raw.volume24h || 0),
+            volume: Number(raw.volume || 0),
+            liquidity: Number(raw.liquidity || 0),
+            url: `https://myriad.markets/markets/${raw.slug || raw.id}`,
+            image: raw.imageUrl,
+            tags: raw.topics || [],
+        };
+        (0, market_utils_1.addBinaryOutcomes)(um);
+        return um;
+    }
+    normalizeEvent(raw) {
+        if (!raw)
+            return null;
+        const markets = [];
+        for (const m of raw.markets || []) {
+            const um = this.normalizeMarket(m);
+            if (um)
+                markets.push(um);
+        }
+        return {
+            id: String(raw.id),
+            title: raw.title || '',
+            description: '',
+            slug: String(raw.id),
+            markets,
+            volume24h: markets.reduce((sum, m) => sum + m.volume24h, 0),
+            volume: markets.some(m => m.volume !== undefined)
+                ? markets.reduce((sum, m) => sum + (m.volume ?? 0), 0)
+                : undefined,
+            url: `https://myriad.markets`,
+        };
+    }
+    normalizeOHLCV(raw, params, outcomeId) {
+        const outcomes = raw.outcomes || [];
+        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 [];
+        }
+        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;
+    }
+    normalizeOrderBook(raw, id) {
+        const parts = id.split(':');
+        const outcomeId = parts.length >= 3 ? parts[2] : undefined;
+        const outcomes = raw.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(raw.liquidity || 0);
+        const size = liquidity > 0 ? liquidity : 1;
+        return {
+            bids: [{ price, size }],
+            asks: [{ price, size }],
+            timestamp: Date.now(),
+        };
+    }
+    normalizeTrade(raw, index) {
+        return {
+            id: `${raw.blockNumber || raw.timestamp}-${index}`,
+            timestamp: (raw.timestamp || 0) * 1000,
+            price: (0, price_1.resolveMyriadPrice)(raw),
+            amount: Number(raw.shares || 0),
+            side: raw.action === 'buy' ? 'buy' : 'sell',
+        };
+    }
+    normalizeUserTrade(raw, index) {
+        return {
+            id: `${raw.blockNumber || raw.timestamp}-${index}`,
+            timestamp: (raw.timestamp || 0) * 1000,
+            price: (0, price_1.resolveMyriadPrice)(raw),
+            amount: Number(raw.shares || 0),
+            side: raw.action === 'buy' ? 'buy' : 'sell',
+        };
+    }
+    normalizePosition(raw) {
+        return {
+            marketId: `${raw.networkId}:${raw.marketId}`,
+            outcomeId: `${raw.networkId}:${raw.marketId}:${raw.outcomeId}`,
+            outcomeLabel: raw.outcomeTitle || `Outcome ${raw.outcomeId}`,
+            size: Number(raw.shares || 0),
+            entryPrice: Number(raw.price || 0),
+            currentPrice: (0, price_1.resolveMyriadPrice)(raw),
+            unrealizedPnL: Number(raw.profit || 0),
+        };
+    }
+    normalizeBalance(rawItems) {
+        let totalValue = 0;
+        for (const pos of rawItems) {
+            totalValue += Number(pos.value || 0);
+        }
+        return [{
+                currency: 'USDC',
+                total: totalValue,
+                available: 0,
+                locked: totalValue,
+            }];
+    }
+}
+exports.MyriadNormalizer = MyriadNormalizer;

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

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