pmxt-core 2.44.5 → 2.45.0

package/dist/exchanges/polymarket/websocket.js

@@ -46,6 +46,7 @@ const goldsky_1 = require("../../subscriber/external/goldsky");
 const watcher_1 = require("../../subscriber/watcher");
 const watch_timeout_1 = require("../../utils/watch-timeout");
 const DEFAULT_CONNECTION_TIMEOUT_MS = 30_000;
+const DEFAULT_SNAPSHOT_FALLBACK_MS = 3_000;
 const MAX_PENDING_TRADES_PER_ASSET = 1000;
 const MAX_USER_CALLBACKS = 100;
 const POLYMARKET_MARKET_WS_URL = 'wss://ws-subscriptions-clob.polymarket.com/ws/market';
@@ -63,7 +64,10 @@ class PolymarketWebSocket {
     orderBooks = new Map();
     config;
     initializationPromise;
+    marketPingInterval = null;
+    callApi;
     constructor(callApi, config = {}) {
+        this.callApi = callApi;
         this.config = config;
         const watcherConfig = this.config.watcherConfig;
         const subscriber = new goldsky_1.GoldSkySubscriber({
@@ -78,12 +82,20 @@ class PolymarketWebSocket {
     async watchOrderBook(outcomeId) {
         await this.ensureInitialized();
         await this.subscribe([outcomeId]);
-        // Return a promise that resolves on the next orderbook update
+        // Return a promise that resolves on the next orderbook update.
+        // If the upstream market channel accepts the subscription but stays
+        // quiet, return a real REST snapshot instead of hanging indefinitely.
+        const resolverEntry = {
+            resolve: () => { },
+            reject: () => { },
+        };
         const dataPromise = new Promise((resolve, reject) => {
+            resolverEntry.resolve = resolve;
+            resolverEntry.reject = reject;
             const existing = this.orderBookResolvers.get(outcomeId) ?? [];
-            this.orderBookResolvers.set(outcomeId, [...existing, { resolve, reject }]);
+            this.orderBookResolvers.set(outcomeId, [...existing, resolverEntry]);
         });
-        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchOrderBook('${outcomeId}')`);
+        return (0, watch_timeout_1.withWatchTimeout)(this.withSnapshotFallback(outcomeId, dataPromise, resolverEntry), this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchOrderBook('${outcomeId}')`);
     }
     async unwatchOrderBook(outcomeId) {
         this.subscribedAssets.delete(outcomeId);
@@ -269,6 +281,7 @@ class PolymarketWebSocket {
             this.ws.close();
             this.ws = null;
         }
+        this.stopMarketHeartbeat();
         this.subscribedAssets.clear();
         this.closeUserChannel();
         this.watcher.close();
@@ -302,11 +315,15 @@ class PolymarketWebSocket {
             }, timeoutMs);
             this.ws.on('open', () => {
                 clearTimeout(timeout);
+                this.startMarketHeartbeat();
                 resolve();
             });
             this.ws.on('message', (raw) => {
                 try {
-                    const msgs = JSON.parse(raw.toString());
+                    const text = raw.toString();
+                    if (text === 'PONG' || text === 'PING')
+                        return;
+                    const msgs = JSON.parse(text);
                     const arr = Array.isArray(msgs) ? msgs : [msgs];
                     for (const msg of arr) {
                         const type = msg.event_type;
@@ -327,9 +344,12 @@ class PolymarketWebSocket {
             this.ws.on('error', (err) => {
                 clearTimeout(timeout);
                 logger_1.logger.error('[polymarket-ws] WebSocket error', { error: err.message });
+                this.rejectPendingMarketResolvers(err);
                 reject(err);
             });
             this.ws.on('close', () => {
+                this.stopMarketHeartbeat();
+                this.rejectPendingMarketResolvers(new Error('Polymarket market channel closed'));
                 this.initializationPromise = undefined;
                 this.ws = null;
             });
@@ -338,21 +358,107 @@ class PolymarketWebSocket {
     }
     handleBookSnapshot(event) {
         const id = event.asset_id;
-        const bids = event.bids.map((b) => ({
-            price: parseFloat(b.price),
-            size: parseFloat(b.size),
+        const orderBook = this.normalizeRawOrderBook(event);
+        this.orderBooks.set(id, orderBook);
+        this.resolveOrderBook(id, orderBook);
+    }
+    withSnapshotFallback(outcomeId, dataPromise, resolverEntry) {
+        const fallbackMs = this.config.snapshotFallbackMs ?? DEFAULT_SNAPSHOT_FALLBACK_MS;
+        if (fallbackMs <= 0)
+            return dataPromise;
+        let timer;
+        const fallbackPromise = new Promise((resolve, reject) => {
+            timer = setTimeout(async () => {
+                this.removeOrderBookResolver(outcomeId, resolverEntry);
+                try {
+                    resolve(await this.fetchOrderBookSnapshot(outcomeId));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }, fallbackMs);
+        });
+        return Promise.race([dataPromise, fallbackPromise]).finally(() => {
+            clearTimeout(timer);
+        });
+    }
+    removeOrderBookResolver(outcomeId, resolverEntry) {
+        const resolvers = this.orderBookResolvers.get(outcomeId);
+        if (!resolvers)
+            return;
+        const filtered = resolvers.filter((entry) => entry !== resolverEntry);
+        if (filtered.length > 0) {
+            this.orderBookResolvers.set(outcomeId, filtered);
+        }
+        else {
+            this.orderBookResolvers.delete(outcomeId);
+        }
+    }
+    async fetchOrderBookSnapshot(outcomeId) {
+        const raw = await this.callApi('getBook', { token_id: outcomeId });
+        const orderBook = this.normalizeRawOrderBook({
+            ...raw,
+            asset_id: raw?.asset_id ?? outcomeId,
+        });
+        this.orderBooks.set(outcomeId, orderBook);
+        return orderBook;
+    }
+    normalizeRawOrderBook(raw) {
+        const bids = (raw?.bids || []).map((level) => ({
+            price: parseFloat(level.price),
+            size: parseFloat(level.size),
         })).sort((a, b) => b.price - a.price);
-        const asks = event.asks.map((a) => ({
-            price: parseFloat(a.price),
-            size: parseFloat(a.size),
+        const asks = (raw?.asks || []).map((level) => ({
+            price: parseFloat(level.price),
+            size: parseFloat(level.size),
         })).sort((a, b) => a.price - b.price);
-        const orderBook = {
+        return {
             bids,
             asks,
-            timestamp: event.timestamp ? (isNaN(Number(event.timestamp)) ? new Date(event.timestamp).getTime() : Number(event.timestamp)) : Date.now(),
+            timestamp: this.parseTimestamp(raw?.timestamp),
         };
-        this.orderBooks.set(id, orderBook);
-        this.resolveOrderBook(id, orderBook);
+    }
+    parseTimestamp(value) {
+        if (typeof value === 'number')
+            return value;
+        if (typeof value === 'string' && value.length > 0) {
+            const numeric = Number(value);
+            return Number.isNaN(numeric) ? new Date(value).getTime() : numeric;
+        }
+        return Date.now();
+    }
+    startMarketHeartbeat() {
+        this.stopMarketHeartbeat();
+        this.marketPingInterval = setInterval(() => {
+            if (this.ws && this.ws.readyState === 1) {
+                try {
+                    this.ws.send('PING');
+                }
+                catch (error) {
+                    logger_1.logger.warn('[polymarket-ws] market heartbeat failed', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }, 10_000);
+    }
+    stopMarketHeartbeat() {
+        if (this.marketPingInterval) {
+            clearInterval(this.marketPingInterval);
+            this.marketPingInterval = null;
+        }
+    }
+    rejectPendingMarketResolvers(error) {
+        for (const [, resolvers] of this.orderBookResolvers) {
+            for (const resolver of resolvers)
+                resolver.reject(error);
+        }
+        this.orderBookResolvers.clear();
+        for (const [, resolvers] of this.tradeResolvers) {
+            for (const resolver of resolvers)
+                resolver.reject(error);
+        }
+        this.tradeResolvers.clear();
     }
     handlePriceChange(event) {
         const id = event.asset_id;

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-05-25T10:52:11.728Z
+ * Generated at: 2026-05-25T15:44:11.722Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const probableApiSpec: {

package/dist/exchanges/probable/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.probableApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-05-25T10:52:11.728Z
+ * Generated at: 2026-05-25T15:44:11.722Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.probableApiSpec = {

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

@@ -0,0 +1,15 @@
+/**
+ * SuiBets P2P Sports Betting API Reference
+ *
+ * This file documents the SuiBets REST API endpoints used by the fetcher.
+ * It is NOT wired into defineImplicitApi — the fetcher calls these endpoints
+ * directly via FetcherContext.http (the rate-limited HTTP client).
+ *
+ * Base URL: https://suibets.replit.app
+ *
+ * Endpoints:
+ *   GET /api/p2p/offers          - List open P2P offers (status, matchId, sport, limit, offset)
+ *   GET /api/p2p/offers/:id      - Get a single P2P offer by ID
+ *   GET /api/p2p/my?wallet=...   - Get user activity (created offers, matched bets, parlays)
+ *   GET /api/events/upcoming     - List upcoming sports events (sport, limit)
+ */

package/dist/exchanges/suibets/api.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * SuiBets P2P Sports Betting API Reference
+ *
+ * This file documents the SuiBets REST API endpoints used by the fetcher.
+ * It is NOT wired into defineImplicitApi — the fetcher calls these endpoints
+ * directly via FetcherContext.http (the rate-limited HTTP client).
+ *
+ * Base URL: https://suibets.replit.app
+ *
+ * Endpoints:
+ *   GET /api/p2p/offers          - List open P2P offers (status, matchId, sport, limit, offset)
+ *   GET /api/p2p/offers/:id      - Get a single P2P offer by ID
+ *   GET /api/p2p/my?wallet=...   - Get user activity (created offers, matched bets, parlays)
+ *   GET /api/events/upcoming     - List upcoming sports events (sport, limit)
+ */
+// No runtime exports — this file serves as API documentation only.

package/dist/exchanges/suibets/config.d.ts

@@ -0,0 +1,16 @@
+export declare const SUIBETS_BASE_URL = "https://suibets.replit.app";
+export declare const SUIBETS_PLATFORM_FEE = 0.02;
+export declare const MIST_PER_SUI = 1000000000;
+export declare const MIN_PRICE = 0.01;
+export declare const MAX_PRICE = 0.99;
+export declare const RATE_LIMIT_MS = 300;
+export declare const ALLOWED_HOSTS: readonly string[];
+/**
+ * Validates that the given URL's hostname is in the ALLOWED_HOSTS allowlist.
+ * Throws if the hostname is not permitted, to prevent SSRF.
+ */
+export declare function validateBaseUrl(url: string): void;
+export interface SuibetsApiConfig {
+    baseUrl: string;
+}
+export declare function getSuibetsConfig(baseUrlOverride?: string): SuibetsApiConfig;

package/dist/exchanges/suibets/config.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_HOSTS = exports.RATE_LIMIT_MS = exports.MAX_PRICE = exports.MIN_PRICE = exports.MIST_PER_SUI = exports.SUIBETS_PLATFORM_FEE = exports.SUIBETS_BASE_URL = void 0;
+exports.validateBaseUrl = validateBaseUrl;
+exports.getSuibetsConfig = getSuibetsConfig;
+exports.SUIBETS_BASE_URL = 'https://suibets.replit.app';
+// SuiBets is a P2P sports betting platform on Sui blockchain.
+// Platform takes a 2% fee on settled markets.
+exports.SUIBETS_PLATFORM_FEE = 0.02;
+// Sui uses MIST as its base unit; 1 SUI = 1,000,000,000 MIST
+exports.MIST_PER_SUI = 1e9;
+// Prices represent probabilities in the range [0.01, 0.99]
+exports.MIN_PRICE = 0.01;
+exports.MAX_PRICE = 0.99;
+// Minimum delay between outbound requests (milliseconds)
+exports.RATE_LIMIT_MS = 300;
+// Allowlist of permitted hostnames for SSRF protection
+exports.ALLOWED_HOSTS = ['suibets.replit.app'];
+/**
+ * Validates that the given URL's hostname is in the ALLOWED_HOSTS allowlist.
+ * Throws if the hostname is not permitted, to prevent SSRF.
+ */
+function validateBaseUrl(url) {
+    const parsed = new URL(url);
+    if (!exports.ALLOWED_HOSTS.includes(parsed.hostname)) {
+        throw new Error(`Base URL hostname "${parsed.hostname}" is not in the SSRF allowlist. ` +
+            `Permitted hosts: ${exports.ALLOWED_HOSTS.join(', ')}`);
+    }
+}
+function getSuibetsConfig(baseUrlOverride) {
+    const baseUrl = baseUrlOverride ?? exports.SUIBETS_BASE_URL;
+    validateBaseUrl(baseUrl);
+    return { baseUrl };
+}

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

@@ -0,0 +1,16 @@
+import { ErrorMapper } from '../../utils/error-mapper';
+/**
+ * Maps SuiBets API errors to PMXT unified error classes.
+ *
+ * SuiBets is a read-only public API, so error mapping focuses on
+ * network errors and rate limits. Error responses are expected in the form:
+ *   { error: string }
+ * or:
+ *   { message: string }
+ */
+export declare class SuibetsErrorMapper extends ErrorMapper {
+    constructor();
+    protected extractErrorMessage(error: unknown): string;
+    mapError(error: unknown): ReturnType<ErrorMapper['mapError']>;
+}
+export declare const suibetsErrorMapper: SuibetsErrorMapper;

package/dist/exchanges/suibets/errors.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suibetsErrorMapper = exports.SuibetsErrorMapper = void 0;
+const axios_1 = __importDefault(require("axios"));
+const error_mapper_1 = require("../../utils/error-mapper");
+const errors_1 = require("../../errors");
+/**
+ * Maps SuiBets API errors to PMXT unified error classes.
+ *
+ * SuiBets is a read-only public API, so error mapping focuses on
+ * network errors and rate limits. Error responses are expected in the form:
+ *   { error: string }
+ * or:
+ *   { message: string }
+ */
+class SuibetsErrorMapper extends error_mapper_1.ErrorMapper {
+    constructor() {
+        super('SuiBets');
+    }
+    extractErrorMessage(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.data) {
+            const data = error.response.data;
+            if (typeof data === 'string') {
+                return `[${error.response.status}] ${data}`;
+            }
+            if (typeof data === 'object' && data !== null) {
+                const obj = data;
+                if (typeof obj.error === 'string') {
+                    return `[${error.response.status}] ${obj.error}`;
+                }
+                if (typeof obj.message === 'string') {
+                    return `[${error.response.status}] ${obj.message}`;
+                }
+            }
+        }
+        return super.extractErrorMessage(error);
+    }
+    mapError(error) {
+        if (axios_1.default.isAxiosError(error)) {
+            const status = error.response?.status;
+            if (status === 429) {
+                const retryAfter = error.response?.headers?.['retry-after'];
+                const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : undefined;
+                return new errors_1.RateLimitExceeded(this.extractErrorMessage(error), retryAfterSeconds, this.exchangeName);
+            }
+            if (status === 401 || status === 403) {
+                return new errors_1.AuthenticationError(this.extractErrorMessage(error), this.exchangeName);
+            }
+            if (status !== undefined && status >= 500) {
+                return new errors_1.ExchangeNotAvailable(`Exchange error (${status}): ${this.extractErrorMessage(error)}`, this.exchangeName);
+            }
+            if (!status) {
+                return new errors_1.NetworkError(`Network error: ${this.extractErrorMessage(error)}`, this.exchangeName);
+            }
+        }
+        if (error instanceof Error && !axios_1.default.isAxiosError(error)) {
+            const nodeErr = error;
+            if (nodeErr.code === 'ECONNREFUSED' ||
+                nodeErr.code === 'ENOTFOUND' ||
+                nodeErr.code === 'ETIMEDOUT') {
+                return new errors_1.NetworkError(`Network error: ${error.message}`, this.exchangeName);
+            }
+        }
+        return super.mapError(error);
+    }
+}
+exports.SuibetsErrorMapper = SuibetsErrorMapper;
+exports.suibetsErrorMapper = new SuibetsErrorMapper();

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

@@ -0,0 +1,64 @@
+import { MarketFilterParams, EventFetchParams } from '../../BaseExchange';
+import { IExchangeFetcher, FetcherContext } from '../interfaces';
+export interface SuibetsRawOffer {
+    id: string;
+    matchId: string;
+    matchName: string;
+    sport: string;
+    homeTeam: string;
+    awayTeam: string;
+    creatorWallet: string;
+    creatorTeam: string;
+    creatorOdds: number;
+    creatorStake: number;
+    takerStake: number;
+    remainingStake?: number;
+    matchDate: string;
+    expiresAt: string;
+    status: string;
+    totalMatched?: number;
+    currency?: string;
+    isOnchain?: boolean;
+    onchainOfferId?: string;
+    leagueName?: string;
+}
+export interface SuibetsRawEvent {
+    id: string;
+    name: string;
+    homeTeam: string;
+    awayTeam: string;
+    sport: string;
+    leagueName?: string;
+    matchDate: string;
+    status: string;
+    offers?: SuibetsRawOffer[];
+}
+export declare class SuibetsFetcher implements IExchangeFetcher<SuibetsRawOffer, SuibetsRawEvent> {
+    private readonly ctx;
+    private readonly baseUrl;
+    constructor(ctx: FetcherContext, baseUrl: string);
+    /**
+     * Performs a GET request via the rate-limited HTTP client provided by the
+     * base class. All errors are mapped to pmxt unified error types.
+     */
+    private get;
+    /**
+     * Fetches raw P2P bet offers from the SuiBets API.
+     *
+     * When `params.query` is set, filtering is applied client-side after
+     * fetching because the API does not support full-text search.
+     */
+    fetchRawMarkets(params?: MarketFilterParams): Promise<SuibetsRawOffer[]>;
+    /**
+     * Fetches raw events by grouping active P2P offers by their matchId.
+     *
+     * SuiBets has no dedicated events endpoint; events are synthesised from
+     * the offers list so each unique match becomes one event.
+     */
+    fetchRawEvents(params: EventFetchParams): Promise<SuibetsRawEvent[]>;
+    /**
+     * Fetches raw positions (created offers, matched bets, parlays) for a
+     * given Sui wallet address.
+     */
+    fetchRawPositions(walletAddress: string): Promise<unknown[]>;
+}

package/dist/exchanges/suibets/fetcher.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuibetsFetcher = void 0;
+const errors_1 = require("./errors");
+class SuibetsFetcher {
+    ctx;
+    baseUrl;
+    constructor(ctx, baseUrl) {
+        this.ctx = ctx;
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+    }
+    /**
+     * Performs a GET request via the rate-limited HTTP client provided by the
+     * base class. All errors are mapped to pmxt unified error types.
+     */
+    async get(path, params) {
+        try {
+            const url = new URL(path, this.baseUrl);
+            if (params) {
+                for (const [k, v] of Object.entries(params)) {
+                    url.searchParams.set(k, v);
+                }
+            }
+            const response = await this.ctx.http.get(url.toString(), {
+                maxContentLength: 5 * 1024 * 1024,
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw errors_1.suibetsErrorMapper.mapError(error);
+        }
+    }
+    /**
+     * Fetches raw P2P bet offers from the SuiBets API.
+     *
+     * When `params.query` is set, filtering is applied client-side after
+     * fetching because the API does not support full-text search.
+     */
+    async fetchRawMarkets(params) {
+        if (params?.marketId) {
+            const id = params.marketId.replace(/^suibets:/, '');
+            const data = await this.get(`/api/p2p/offers/${id}`);
+            const offer = data.offer ?? data;
+            return offer ? [offer] : [];
+        }
+        const baseParams = {
+            status: params?.status === 'all' ? 'all' : 'OPEN',
+            limit: String(params?.limit ?? 50),
+            offset: String(params?.offset ?? 0),
+        };
+        const queryParams = params?.eventId
+            ? { ...baseParams, matchId: params.eventId.replace(/^suibets:/, '') }
+            : { ...baseParams };
+        const data = await this.get('/api/p2p/offers', queryParams);
+        const offers = data.offers ??
+            (Array.isArray(data) ? data : []);
+        if (!params?.query) {
+            return offers;
+        }
+        // Client-side text filter: the API has no search endpoint.
+        const q = params.query.toLowerCase();
+        return offers.filter(o => o.matchName?.toLowerCase().includes(q) ||
+            o.homeTeam?.toLowerCase().includes(q) ||
+            o.awayTeam?.toLowerCase().includes(q) ||
+            o.sport?.toLowerCase().includes(q));
+    }
+    /**
+     * Fetches raw events by grouping active P2P offers by their matchId.
+     *
+     * SuiBets has no dedicated events endpoint; events are synthesised from
+     * the offers list so each unique match becomes one event.
+     */
+    async fetchRawEvents(params) {
+        const queryParams = {
+            status: 'OPEN',
+            limit: String(params.limit ?? 100),
+        };
+        const data = await this.get('/api/p2p/offers', queryParams);
+        const offers = data.offers ??
+            (Array.isArray(data) ? data : []);
+        // Group offers by matchId using a Map; each entry is built immutably.
+        const byMatch = new Map();
+        for (const offer of offers) {
+            if (!offer.matchId)
+                continue;
+            const existing = byMatch.get(offer.matchId) ?? [];
+            byMatch.set(offer.matchId, [...existing, offer]);
+        }
+        const q = params.query?.toLowerCase();
+        const events = [];
+        for (const [matchId, matchOffers] of byMatch) {
+            const first = matchOffers[0];
+            if (q) {
+                const matches = first.matchName?.toLowerCase().includes(q) ||
+                    first.homeTeam?.toLowerCase().includes(q) ||
+                    first.awayTeam?.toLowerCase().includes(q) ||
+                    first.sport?.toLowerCase().includes(q);
+                if (!matches)
+                    continue;
+            }
+            events.push({
+                id: matchId,
+                name: first.matchName || `${first.homeTeam} vs ${first.awayTeam}`,
+                homeTeam: first.homeTeam,
+                awayTeam: first.awayTeam,
+                sport: first.sport,
+                leagueName: first.leagueName,
+                matchDate: first.matchDate,
+                status: 'active',
+                offers: matchOffers,
+            });
+        }
+        return events;
+    }
+    /**
+     * Fetches raw positions (created offers, matched bets, parlays) for a
+     * given Sui wallet address.
+     */
+    async fetchRawPositions(walletAddress) {
+        const data = await this.get('/api/p2p/my', { wallet: walletAddress });
+        return [
+            ...(data.createdOffers ?? []),
+            ...(data.matchedBets ?? []),
+            ...(data.parlays ?? []),
+        ];
+    }
+}
+exports.SuibetsFetcher = SuibetsFetcher;

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

@@ -0,0 +1,54 @@
+import { PredictionMarketExchange, MarketFilterParams, EventFetchParams, ExchangeCredentials } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, OrderBook, Position } from '../../types';
+export interface SuibetsCredentials extends ExchangeCredentials {
+    /** Sui wallet address for fetching personal positions */
+    walletAddress?: string;
+    /** Override API base URL (default: https://suibets.replit.app) */
+    baseUrl?: string;
+}
+/**
+ * SuiBets — Decentralised P2P sports betting on Sui blockchain.
+ *
+ * Maps P2P bet offers to the pmxt unified market model:
+ *   - Market  = one P2P offer (creator side vs taker side)
+ *   - Event   = a sports match (groups all offers for that match)
+ *   - Outcome = creator's pick (YES) or opposite (NO)
+ *   - Price   = implied probability derived from the offer odds
+ *
+ * Usage:
+ * ```ts
+ * import pmxt from 'pmxtjs';
+ * const exchange = new pmxt.SuiBets();
+ * const markets = await exchange.fetchMarkets({ limit: 20 });
+ * ```
+ */
+export declare class SuiBetsExchange extends PredictionMarketExchange {
+    protected readonly capabilityOverrides: {
+        fetchOrderBook: "emulated";
+        createOrder: false;
+        cancelOrder: false;
+        fetchOrder: false;
+        fetchOpenOrders: false;
+        fetchBalance: false;
+        fetchPositions: true;
+        watchOrderBook: false;
+        watchTrades: false;
+    };
+    private readonly config;
+    private readonly fetcher;
+    private readonly normalizer;
+    private readonly walletAddress?;
+    constructor(credentials?: SuibetsCredentials);
+    get name(): string;
+    protected sign(): Record<string, string>;
+    protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    /**
+     * Emulated order book derived from offer odds.
+     *
+     * Bid side: what buyers pay to back the creator's pick (YES price).
+     * Ask side: what sellers want to take the opposite side (NO price).
+     */
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    fetchPositions(): Promise<Position[]>;
+}