pmxt-core 2.39.0 → 2.40.0

package/dist/exchanges/mock/index.js

@@ -0,0 +1,603 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockExchange = void 0;
+const BaseExchange_1 = require("../../BaseExchange");
+const seededRng_1 = require("./seededRng");
+const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+const round = (n, decimals = 3) => parseFloat(n.toFixed(decimals));
+const CATEGORIES = ['Politics', 'Sports', 'Crypto', 'Finance', 'Science', 'Entertainment', 'Tech', 'World'];
+const LOREM = `lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor
+incididunt ut labore et dolore magna aliqua enim ad minim veniam quis nostrud
+exercitation ullamco laboris nisi aliquip ex ea commodo consequat duis aute
+irure dolor reprehenderit voluptate velit esse cillum dolore fugiat nulla
+pariatur excepteur sint occaecat cupidatat non proident mollit anim id est
+laborum sollicitudin ultricies tellus pellentesque curabitur elementum
+hendrerit metus aenean pharetra magna accumsan`.split(/\s+/);
+const ADJECTIVES = [
+    'rapid', 'quiet', 'major', 'sunny', 'clever', 'brisk', 'gentle', 'fierce', 'distant', 'noble', 'hollow', 'fuzzy',
+];
+const NOUNS = [
+    'event', 'market', 'race', 'trend', 'signal', 'storm', 'ledger', 'summit', 'forum', 'arena', 'harbor', 'vessel',
+];
+const FIRST_NAMES = ['Alex', 'Jordan', 'Sam', 'Riley', 'Morgan', 'Quinn', 'Avery', 'Parker', 'Drew', 'Sage', 'Jules', 'Remy'];
+const LAST_NAMES = ['Nguyen', 'Garcia', 'Patel', 'Silva', 'Berg', 'Wright', 'Choi', 'Diaz', 'Reed', 'Stone', 'Singh', 'Cole'];
+const BINARY_TEMPLATES = [
+    'Will {name} win the {year} {event}?',
+    'Will {country} GDP grow above {pct}% in {year}?',
+    'Will {asset} reach ${price}k by end of {year}?',
+    'Will {name} be elected {role}?',
+    'Will {company} IPO before {month} {year}?',
+    'Will {name} announce {product} at {event}?',
+    'Will {country} join {org} by {year}?',
+    'Will {sport} season start on time in {year}?',
+];
+const MULTI_TEMPLATES = [
+    'Who will win the {year} {event}?',
+    'Which party wins the {year} {country} election?',
+    'What will {asset} price be at end of {year}?',
+];
+const CANDIDATES = [
+    ['Alice Johnson', 'Bob Smith', 'Carol Williams', 'David Brown'],
+    ['Party A', 'Party B', 'Party C', 'Independent'],
+    ['Below $50k', '$50k-$100k', '$100k-$150k', 'Above $150k'],
+    ['Q1', 'Q2', 'Q3', 'Q4'],
+];
+const ASSETS = ['BTC', 'ETH', 'SOL', 'Gold'];
+const ROLES = ['President', 'CEO', 'Governor', 'Mayor'];
+const ORGS = ['NATO', 'EU', 'BRICS', 'G7'];
+const SPORTS = ['NFL', 'NBA', 'MLB', 'NHL'];
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const PICK_WORDS = {
+    company: ['Acme', 'Nimbus', 'Vanta', 'Quanta', 'Helio', 'Orbit', 'Vector', 'Prism', 'Axiom', 'Cipher'],
+    product: ['Widget', 'Console', 'Platform', 'Suite', 'Cloud', 'Network', 'Stack', 'Engine', 'Hub', 'Node'],
+    month: [...MONTHS],
+};
+function loremWords(r, count) {
+    const w = [];
+    for (let i = 0; i < count; i++)
+        w.push(r.pick(LOREM));
+    return w.join(' ');
+}
+const rng = (seed) => new seededRng_1.SeededRng(seed);
+class MockExchange extends BaseExchange_1.PredictionMarketExchange {
+    _marketCount;
+    _initialBalance;
+    _orderLatencyMs;
+    _limitOrderMode;
+    _generatedMarkets;
+    _generatedEvents;
+    _freeCash;
+    _ordSeq = 0;
+    _orders = new Map();
+    _lockedByBuy = new Map();
+    _positions = new Map();
+    _myTrades = [];
+    constructor(options) {
+        super();
+        this._marketCount = options?.marketCount ?? 50;
+        this._initialBalance = options?.balance ?? 1000;
+        this._freeCash = this._initialBalance;
+        this._orderLatencyMs = options?.orderLatencyMs ?? 100;
+        this._limitOrderMode = options?.limitOrderMode ?? 'immediate';
+    }
+    get name() {
+        return 'Mock';
+    }
+    _locked() {
+        let s = 0;
+        for (const v of this._lockedByBuy.values())
+            s += v;
+        return s;
+    }
+    _bookMidPrice(outcomeId) {
+        const r = new seededRng_1.SeededRng(outcomeId);
+        return round(r.float(0.1, 0.9), 3);
+    }
+    _generateMarket(seed, eventId, isBinary) {
+        const f = rng(seed);
+        const year = new Date().getFullYear() + f.int(0, 2);
+        const category = f.pick(CATEGORIES);
+        let title;
+        if (isBinary) {
+            const t = f.pick(BINARY_TEMPLATES);
+            const country = f.pick(NOUNS) + f.pick(['ia', 'land', 'stan']);
+            title = t
+                .replace('{name}', `${f.pick(FIRST_NAMES)} ${f.pick(LAST_NAMES)}`)
+                .replace('{year}', String(year))
+                .replace('{event}', f.pick(NOUNS))
+                .replace('{country}', country)
+                .replace('{pct}', String(f.int(1, 8)))
+                .replace('{asset}', f.pick(ASSETS))
+                .replace('{price}', String(f.int(50, 500)))
+                .replace('{role}', f.pick(ROLES))
+                .replace('{company}', f.pick(PICK_WORDS.company))
+                .replace('{month}', f.pick(MONTHS))
+                .replace('{product}', f.pick(PICK_WORDS.product))
+                .replace('{org}', f.pick(ORGS))
+                .replace('{sport}', f.pick(SPORTS));
+        }
+        else {
+            title = f
+                .pick(MULTI_TEMPLATES)
+                .replace('{name}', `${f.pick(FIRST_NAMES)} ${f.pick(LAST_NAMES)}`)
+                .replace('{year}', String(year))
+                .replace('{event}', f.pick(NOUNS))
+                .replace('{country}', f.pick(NOUNS) + f.pick(['ia', 'land']))
+                .replace('{asset}', f.pick(ASSETS));
+        }
+        const resolutionDate = new Date(Date.now() + f.int(30, 800) * 86_400_000);
+        const volume24h = round(f.float(0, 500_000), 2);
+        const volume = round(volume24h * f.float(1, 50), 2);
+        const liquidity = round(f.float(500, 200_000), 2);
+        const openInterest = round(f.float(100, 80_000), 2);
+        const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 60);
+        const marketId = `mock-${seed}`;
+        const tags = [category.toLowerCase(), String(year)];
+        let outcomes;
+        if (isBinary) {
+            const yesPrice = round(f.float(0.05, 0.95), 3);
+            const noPrice = round(1 - yesPrice, 3);
+            const yesChange = round(f.float(-0.1, 0.1), 3);
+            outcomes = [
+                {
+                    outcomeId: `${marketId}-yes`,
+                    marketId,
+                    label: 'Yes',
+                    price: yesPrice,
+                    priceChange24h: yesChange,
+                    metadata: { clobTokenId: `mock-clob-${seed}-yes` },
+                },
+                {
+                    outcomeId: `${marketId}-no`,
+                    marketId,
+                    label: 'No',
+                    price: noPrice,
+                    priceChange24h: -yesChange,
+                    metadata: { clobTokenId: `mock-clob-${seed}-no` },
+                },
+            ];
+        }
+        else {
+            const candidates = f.pick(CANDIDATES);
+            const rawPrices = candidates.map(() => f.float(0.05, 0.9));
+            const total = rawPrices.reduce((s, p) => s + p, 0);
+            outcomes = candidates.map((label, i) => ({
+                outcomeId: `${marketId}-${i}`,
+                marketId,
+                label,
+                price: round(rawPrices[i] / total, 3),
+                priceChange24h: round(f.float(-0.05, 0.05), 3),
+                metadata: { clobTokenId: `mock-clob-${seed}-${i}` },
+            }));
+        }
+        const market = {
+            marketId,
+            eventId,
+            title,
+            description: loremWords(f, 20 + f.int(0, 20)),
+            slug,
+            outcomes,
+            resolutionDate,
+            volume24h,
+            volume,
+            liquidity,
+            openInterest,
+            url: `https://mock.pmxt.dev/market/${slug}`,
+            image: `https://picsum.photos/seed/${encodeURIComponent(seed)}/400/200`,
+            category,
+            tags,
+            status: 'active',
+            tickSize: 0.01,
+            contractAddress: `0xmock${seed.replace(/[^a-z0-9]/gi, '')}`,
+            sourceExchange: 'mock',
+        };
+        if (isBinary) {
+            market.yes = outcomes[0];
+            market.no = outcomes[1];
+        }
+        if (!isBinary && outcomes.length === 2) {
+            market.up = outcomes[0];
+            market.down = outcomes[1];
+        }
+        return market;
+    }
+    _buildMarkets() {
+        if (this._generatedMarkets)
+            return this._generatedMarkets;
+        const markets = [];
+        for (let i = 0; i < this._marketCount; i++) {
+            const isBinary = i % 4 !== 0;
+            const eventIdx = Math.floor(i / 3);
+            markets.push(this._generateMarket(`m${i}`, `mock-event-${eventIdx}`, isBinary));
+        }
+        this._generatedMarkets = markets;
+        return markets;
+    }
+    _buildEvents() {
+        if (this._generatedEvents)
+            return this._generatedEvents;
+        const markets = this._buildMarkets();
+        const eventMap = new Map();
+        for (const m of markets) {
+            if (!m.eventId)
+                continue;
+            if (!eventMap.has(m.eventId))
+                eventMap.set(m.eventId, []);
+            eventMap.get(m.eventId).push(m);
+        }
+        const events = [];
+        for (const [eventId, eventMarkets] of eventMap) {
+            const f = rng(eventId);
+            const first = eventMarkets[0];
+            const volume24h = round(eventMarkets.reduce((s, m) => s + m.volume24h, 0), 2);
+            const volume = round(eventMarkets.reduce((s, m) => s + (m.volume ?? 0), 0), 2);
+            events.push({
+                id: eventId,
+                title: `Mock Event: ${f.pick(ADJECTIVES)} ${f.pick(NOUNS)}`,
+                description: loremWords(f, 18 + f.int(0, 15)),
+                slug: eventId,
+                markets: eventMarkets,
+                volume24h,
+                volume,
+                url: `https://mock.pmxt.dev/event/${eventId}`,
+                image: `https://picsum.photos/seed/${encodeURIComponent(eventId)}/800/400`,
+                category: first.category,
+                tags: first.tags,
+                sourceExchange: 'mock',
+            });
+        }
+        this._generatedEvents = events;
+        return events;
+    }
+    async fetchMarketsImpl(params) {
+        let markets = this._buildMarkets();
+        if (params?.query) {
+            const q = params.query.toLowerCase();
+            markets = markets.filter(m => m.title.toLowerCase().includes(q));
+        }
+        if (params?.eventId) {
+            markets = markets.filter(m => m.eventId === params.eventId);
+        }
+        if (params?.marketId) {
+            markets = markets.filter(m => m.marketId === params.marketId);
+        }
+        const offset = params?.offset ?? 0;
+        const limit = params?.limit;
+        return limit !== undefined ? markets.slice(offset, offset + limit) : markets.slice(offset);
+    }
+    async fetchEventsImpl(params) {
+        let events = this._buildEvents();
+        if (params?.query) {
+            const q = params.query.toLowerCase();
+            events = events.filter(e => e.title.toLowerCase().includes(q));
+        }
+        if (params?.eventId) {
+            events = events.filter(e => e.id === params.eventId);
+        }
+        const offset = params?.offset ?? 0;
+        const limit = params?.limit;
+        return limit !== undefined ? events.slice(offset, offset + limit) : events.slice(offset);
+    }
+    async fetchOrderBook(id) {
+        const f = new seededRng_1.SeededRng(id);
+        const midPrice = round(f.float(0.1, 0.9), 3);
+        const spread = round(f.float(0.005, 0.03), 3);
+        const buildLevels = (startPrice, direction, count) => {
+            const levels = [];
+            let price = startPrice;
+            for (let i = 0; i < count; i++) {
+                price = clamp(round(price + direction * f.float(0.002, 0.01), 3), 0.01, 0.99);
+                const size = round(f.float(10, 2000), 0);
+                levels.push({ price, size });
+            }
+            return levels;
+        };
+        const askStart = clamp(round(midPrice + spread / 2, 3), 0.01, 0.99);
+        const bidStart = clamp(round(midPrice - spread / 2, 3), 0.01, 0.99);
+        return {
+            bids: buildLevels(bidStart, -1, 8).sort((a, b) => b.price - a.price),
+            asks: buildLevels(askStart, 1, 8).sort((a, b) => a.price - b.price),
+            timestamp: Date.now(),
+        };
+    }
+    async fetchOHLCV(id, params) {
+        const f = new seededRng_1.SeededRng(id);
+        const resolutionMs = {
+            '1m': 60_000,
+            '5m': 300_000,
+            '15m': 900_000,
+            '1h': 3_600_000,
+            '6h': 21_600_000,
+            '1d': 86_400_000,
+        };
+        const step = resolutionMs[params.resolution] ?? 3_600_000;
+        const limit = params.limit ?? 100;
+        const end = params.end ? params.end.getTime() : Date.now();
+        const start = params.start ? params.start.getTime() : end - step * limit;
+        const candles = [];
+        let price = round(f.float(0.2, 0.8), 3);
+        let t = start;
+        while (t <= end && candles.length < limit) {
+            const drift = f.float(-0.03, 0.03);
+            const open = clamp(price, 0.01, 0.99);
+            const high = clamp(round(open + Math.abs(f.float(0, 0.05)), 3), 0.01, 0.99);
+            const low = clamp(round(open - Math.abs(f.float(0, 0.05)), 3), 0.01, 0.99);
+            const close = clamp(round(open + drift, 3), 0.01, 0.99);
+            const vol = round(f.float(100, 50_000), 2);
+            candles.push({ timestamp: t, open, high, low, close, volume: vol });
+            price = close;
+            t += step;
+        }
+        return candles;
+    }
+    async fetchTrades(id, _params) {
+        const f = new seededRng_1.SeededRng(id);
+        const count = f.int(5, 30);
+        const trades = [];
+        let ts = Date.now() - count * 60_000;
+        for (let i = 0; i < count; i++) {
+            ts += f.int(5_000, 120_000);
+            trades.push({
+                id: f.uuid(),
+                timestamp: ts,
+                price: round(f.float(0.1, 0.9), 3),
+                amount: round(f.float(1, 500), 0),
+                side: f.pick(['buy', 'sell']),
+                outcomeId: id,
+            });
+        }
+        return trades.sort((a, b) => b.timestamp - a.timestamp);
+    }
+    async fetchBalance(_address) {
+        const locked = this._locked();
+        return [
+            {
+                currency: 'USDC',
+                total: round(this._freeCash + locked, 2),
+                available: round(this._freeCash, 2),
+                locked: round(locked, 2),
+            },
+        ];
+    }
+    async fetchPositions(_address) {
+        return Array.from(this._positions.values());
+    }
+    _nextOrderId(f) {
+        this._ordSeq += 1;
+        return `mock-order-${this._ordSeq}-${f.alphanumeric(6)}`;
+    }
+    _setPosition(params, price, sizeDelta) {
+        const posKey = `${params.marketId}:${params.outcomeId}`;
+        const existing = this._positions.get(posKey);
+        const newSize = (existing ? existing.size : 0) + sizeDelta;
+        if (Math.abs(newSize) < 0.001) {
+            this._positions.delete(posKey);
+            return;
+        }
+        const markets = this._buildMarkets();
+        const market = markets.find(m => m.marketId === params.marketId);
+        const outcome = market?.outcomes.find(o => o.outcomeId === params.outcomeId);
+        if (existing) {
+            const epx = existing.entryPrice * existing.size;
+            const npx = price * sizeDelta;
+            const newEntry = (epx + npx) / newSize;
+            const ep = round(newEntry, 4);
+            const cur = price;
+            this._positions.set(posKey, {
+                marketId: params.marketId,
+                outcomeId: params.outcomeId,
+                outcomeLabel: outcome?.label ?? params.outcomeId,
+                size: round(newSize, 4),
+                entryPrice: ep,
+                currentPrice: cur,
+                unrealizedPnL: round((cur - ep) * newSize, 4),
+            });
+        }
+        else {
+            this._positions.set(posKey, {
+                marketId: params.marketId,
+                outcomeId: params.outcomeId,
+                outcomeLabel: outcome?.label ?? params.outcomeId,
+                size: round(newSize, 4),
+                entryPrice: price,
+                currentPrice: price,
+                unrealizedPnL: 0,
+            });
+        }
+    }
+    _pushTrade(f, params, orderId, price, amount, ts) {
+        this._myTrades.push({
+            id: f.uuid(),
+            timestamp: ts,
+            price,
+            amount,
+            side: params.side,
+            outcomeId: params.outcomeId,
+            orderId,
+        });
+    }
+    _applyInstantFill(params, orderId, price, amount, ts, f) {
+        const cost = price * amount;
+        const order = {
+            id: orderId,
+            marketId: params.marketId,
+            outcomeId: params.outcomeId,
+            side: params.side,
+            type: params.type,
+            price,
+            amount,
+            status: 'filled',
+            filled: amount,
+            remaining: 0,
+            timestamp: ts,
+            fee: round(cost * 0.001, 4),
+        };
+        this._orders.set(orderId, order);
+        if (params.side === 'buy') {
+            this._freeCash = Math.max(0, this._freeCash - cost);
+        }
+        else {
+            this._freeCash += cost;
+        }
+        const sizeChange = params.side === 'buy' ? amount : -amount;
+        this._setPosition(params, price, sizeChange);
+        this._pushTrade(f, params, orderId, price, amount, ts);
+        return { ...this._orders.get(orderId) };
+    }
+    _placeRestingLimit(params, ts, price) {
+        const ro = new seededRng_1.SeededRng('oid:' + this._ordSeq);
+        const orderId = this._nextOrderId(ro);
+        if (params.side === 'buy') {
+            const cost = price * params.amount;
+            if (this._freeCash < cost) {
+                throw new Error('MockExchange: insufficient USDC for resting buy');
+            }
+            this._freeCash -= cost;
+            this._lockedByBuy.set(orderId, cost);
+        }
+        const order = {
+            id: orderId,
+            marketId: params.marketId,
+            outcomeId: params.outcomeId,
+            side: params.side,
+            type: 'limit',
+            price,
+            amount: params.amount,
+            status: 'open',
+            filled: 0,
+            remaining: params.amount,
+            timestamp: ts,
+            fee: 0,
+        };
+        this._orders.set(orderId, order);
+        return { ...order };
+    }
+    async createOrder(params) {
+        if (this._orderLatencyMs > 0) {
+            await new Promise(resolve => setTimeout(resolve, this._orderLatencyMs));
+        }
+        const f = rng(`co:${params.outcomeId}`);
+        const ts = Date.now();
+        const isResting = this._limitOrderMode === 'resting' && params.type === 'limit';
+        const mid = this._bookMidPrice(params.outcomeId);
+        const price = params.type === 'market' ? mid : (params.price ?? round(f.float(0.1, 0.9), 3));
+        if (isResting) {
+            return this._placeRestingLimit(params, ts, price);
+        }
+        const ro = new seededRng_1.SeededRng('oid:' + (this._ordSeq + 1));
+        const orderId = this._nextOrderId(ro);
+        return this._applyInstantFill(params, orderId, price, params.amount, ts, f);
+    }
+    async fillOrder(orderId, amount) {
+        const current = this._orders.get(orderId);
+        if (!current) {
+            throw new Error(`Order not found: ${orderId}`);
+        }
+        if (current.status !== 'open' && current.status !== 'pending') {
+            throw new Error(`MockExchange#fillOrder: order is ${current.status}`);
+        }
+        const f = rng(`fill:${orderId}`);
+        const rem = current.remaining;
+        const fillAmt = amount === undefined ? rem : Math.min(rem, amount);
+        if (fillAmt <= 0) {
+            return { ...current };
+        }
+        const p = current.price ?? 0;
+        const newFilled = current.filled + fillAmt;
+        const newRem = rem - fillAmt;
+        const ts = Date.now();
+        const fillCost = p * fillAmt;
+        const done = newRem < 0.0001;
+        const next = {
+            ...current,
+            status: done ? 'filled' : 'open',
+            filled: newFilled,
+            remaining: done ? 0 : newRem,
+            fee: round(p * newFilled * 0.001, 4),
+            timestamp: ts,
+        };
+        const cp = {
+            marketId: current.marketId,
+            outcomeId: current.outcomeId,
+            side: current.side,
+            type: current.type,
+            price: p,
+            amount: fillAmt,
+        };
+        if (current.side === 'buy') {
+            const lock = this._lockedByBuy.get(orderId) ?? 0;
+            const release = fillCost;
+            const left = lock - release;
+            if (left <= 0.0001) {
+                this._lockedByBuy.delete(orderId);
+            }
+            else {
+                this._lockedByBuy.set(orderId, left);
+            }
+        }
+        else {
+            this._freeCash += fillCost;
+        }
+        this._setPosition(cp, p, current.side === 'buy' ? fillAmt : -fillAmt);
+        this._pushTrade(f, cp, orderId, p, fillAmt, ts);
+        this._orders.set(orderId, next);
+        return { ...this._orders.get(orderId) };
+    }
+    async cancelOrder(orderId) {
+        const current = this._orders.get(orderId);
+        if (!current) {
+            throw new Error(`Order not found: ${orderId}`);
+        }
+        if (current.status !== 'open' && current.status !== 'pending') {
+            throw new Error(`Cannot cancel order in status "${current.status}"`);
+        }
+        const rest = this._lockedByBuy.get(orderId);
+        if (rest !== undefined) {
+            this._freeCash += rest;
+            this._lockedByBuy.delete(orderId);
+        }
+        const u = { ...current, status: 'cancelled', remaining: 0, timestamp: Date.now() };
+        this._orders.set(orderId, u);
+        return { ...u };
+    }
+    async fetchOrder(orderId) {
+        const o = this._orders.get(orderId);
+        if (!o)
+            throw new Error(`Order not found: ${orderId}`);
+        return { ...o };
+    }
+    async fetchOpenOrders(_marketId) {
+        return Array.from(this._orders.values())
+            .filter(o => o.status === 'open' || o.status === 'pending')
+            .map(o => ({ ...o }));
+    }
+    async fetchMyTrades(_params) {
+        let trades = [...this._myTrades];
+        if (_params?.outcomeId)
+            trades = trades.filter(t => t.outcomeId === _params.outcomeId);
+        return trades.sort((a, b) => b.timestamp - a.timestamp);
+    }
+    async fetchClosedOrders() {
+        return Array.from(this._orders.values())
+            .filter(o => o.status === 'filled' || o.status === 'cancelled' || o.status === 'rejected')
+            .map(o => ({ ...o }));
+    }
+    async fetchAllOrders() {
+        return Array.from(this._orders.values()).map(o => ({ ...o }));
+    }
+    async buildOrder(params) {
+        return { exchange: this.name, params, raw: params };
+    }
+    async submitOrder(built) {
+        return this.createOrder(built.params);
+    }
+    reset() {
+        this._freeCash = this._initialBalance;
+        this._ordSeq = 0;
+        this._orders.clear();
+        this._lockedByBuy.clear();
+        this._positions.clear();
+        this._myTrades = [];
+    }
+}
+exports.MockExchange = MockExchange;

package/dist/exchanges/mock/seededRng.d.ts

@@ -0,0 +1,10 @@
+export declare class SeededRng {
+    private state;
+    constructor(seed: string);
+    next(): number;
+    int(min: number, max: number): number;
+    float(min: number, max: number): number;
+    pick<T>(arr: readonly T[]): T;
+    alphanumeric(len: number): string;
+    uuid(): string;
+}

package/dist/exchanges/mock/seededRng.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeededRng = void 0;
+function hashString(s) {
+    let h = 0;
+    for (let i = 0; i < s.length; i++)
+        h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+    return h || 1;
+}
+class SeededRng {
+    state;
+    constructor(seed) {
+        this.state = hashString(seed);
+    }
+    next() {
+        let t = (this.state + 0x6d2b79f5) | 0;
+        this.state = t;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    }
+    int(min, max) {
+        return min + Math.floor(this.next() * (max - min + 1));
+    }
+    float(min, max) {
+        return min + this.next() * (max - min);
+    }
+    pick(arr) {
+        if (arr.length === 0)
+            throw new Error('SeededRng.pick: empty array');
+        return arr[this.int(0, arr.length - 1)];
+    }
+    alphanumeric(len) {
+        const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        let s = '';
+        for (let i = 0; i < len; i++)
+            s += this.pick([...chars]);
+        return s;
+    }
+    uuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+            const r = (this.next() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+}
+exports.SeededRng = SeededRng;

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-05-08T20:27:07.090Z
+ * Generated at: 2026-05-08T22:46:15.514Z
  * 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-05-08T20:27:07.090Z
+ * Generated at: 2026-05-08T22:46:15.514Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.myriadApiSpec = {

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

@@ -7,8 +7,12 @@ export declare class MyriadWebSocket {
     private orderBookTimers;
     private tradeTimers;
     private orderBookResolvers;
+    private orderBookRejecters;
     private tradeResolvers;
+    private tradeRejecters;
     private lastTradeTimestamp;
+    private orderBookFailureCount;
+    private tradeFailureCount;
     private closed;
     constructor(callApi: (operationId: string, params?: Record<string, any>) => Promise<any>, fetchOrderBook: FetchOrderBookFn, pollInterval?: number);
     watchOrderBook(outcomeId: string): Promise<OrderBook>;