pmxt-core 2.44.6 → 2.45.0

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[]>;
+}

package/dist/exchanges/suibets/index.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiBetsExchange = void 0;
+const BaseExchange_1 = require("../../BaseExchange");
+const errors_1 = require("../../errors");
+const config_1 = require("./config");
+const fetcher_1 = require("./fetcher");
+const normalizer_1 = require("./normalizer");
+const utils_1 = require("./utils");
+/**
+ * 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 });
+ * ```
+ */
+class SuiBetsExchange extends BaseExchange_1.PredictionMarketExchange {
+    capabilityOverrides = {
+        fetchOrderBook: 'emulated',
+        createOrder: false,
+        cancelOrder: false,
+        fetchOrder: false,
+        fetchOpenOrders: false,
+        fetchBalance: false,
+        fetchPositions: true,
+        watchOrderBook: false,
+        watchTrades: false,
+    };
+    config;
+    fetcher;
+    normalizer;
+    walletAddress;
+    constructor(credentials) {
+        super(credentials);
+        this.rateLimit = config_1.RATE_LIMIT_MS;
+        this.walletAddress = credentials?.walletAddress;
+        if (credentials?.baseUrl) {
+            (0, config_1.validateBaseUrl)(credentials.baseUrl);
+        }
+        this.config = (0, config_1.getSuibetsConfig)(credentials?.baseUrl);
+        const ctx = {
+            http: this.http,
+            callApi: this.callApi.bind(this),
+            getHeaders: () => ({}),
+        };
+        this.fetcher = new fetcher_1.SuibetsFetcher(ctx, this.config.baseUrl);
+        this.normalizer = new normalizer_1.SuibetsNormalizer();
+    }
+    get name() {
+        return 'SuiBets';
+    }
+    // SuiBets is a public API -- no request signing required
+    sign() {
+        return {};
+    }
+    // -------------------------------------------------------------------------
+    // Market Data
+    // -------------------------------------------------------------------------
+    async fetchMarketsImpl(params) {
+        const raw = await this.fetcher.fetchRawMarkets(params);
+        return raw
+            .map(r => this.normalizer.normalizeMarket(r))
+            .filter((m) => m !== null);
+    }
+    async fetchEventsImpl(params) {
+        const raw = await this.fetcher.fetchRawEvents(params);
+        return raw
+            .map(r => this.normalizer.normalizeEvent(r))
+            .filter((e) => e !== null);
+    }
+    /**
+     * 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).
+     */
+    async fetchOrderBook(outcomeId) {
+        const { offerId } = (0, utils_1.fromOutcomeId)(outcomeId);
+        const markets = await this.fetchMarketsImpl({ marketId: `suibets:${offerId}` });
+        const market = markets[0];
+        if (!market)
+            return { bids: [], asks: [], timestamp: Date.now() };
+        const yes = market.outcomes[0];
+        const no = market.outcomes[1];
+        const size = market.liquidity;
+        return {
+            bids: [{ price: yes.price, size }],
+            asks: [{ price: no.price, size }],
+            timestamp: Date.now(),
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Positions (read-only -- requires walletAddress)
+    // -------------------------------------------------------------------------
+    async fetchPositions() {
+        const wallet = this.walletAddress;
+        if (!wallet) {
+            throw new errors_1.AuthenticationError('fetchPositions() requires a walletAddress. ' +
+                'Pass it via new SuiBetsExchange({ walletAddress: "0x..." }).', 'SuiBets');
+        }
+        const raw = await this.fetcher.fetchRawPositions(wallet);
+        return raw.map(r => this.normalizer.normalizePosition(r));
+    }
+}
+exports.SuiBetsExchange = SuiBetsExchange;

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

@@ -0,0 +1,8 @@
+import { IExchangeNormalizer } from '../interfaces';
+import { UnifiedMarket, UnifiedEvent, Position } from '../../types';
+import { SuibetsRawOffer, SuibetsRawEvent } from './fetcher';
+export declare class SuibetsNormalizer implements IExchangeNormalizer<SuibetsRawOffer, SuibetsRawEvent> {
+    normalizeMarket(raw: SuibetsRawOffer): UnifiedMarket | null;
+    normalizeEvent(raw: SuibetsRawEvent): UnifiedEvent | null;
+    normalizePosition(raw: SuibetsRawOffer): Position;
+}

package/dist/exchanges/suibets/normalizer.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuibetsNormalizer = void 0;
+const utils_1 = require("./utils");
+function liquidity(offer) {
+    const remaining = offer.remainingStake ?? offer.creatorStake;
+    return (0, utils_1.mistToSui)(remaining);
+}
+class SuibetsNormalizer {
+    normalizeMarket(raw) {
+        if (!raw?.id)
+            return null;
+        const dateSource = raw.matchDate || raw.expiresAt;
+        if (!dateSource) {
+            throw new Error(`SuibetsNormalizer: offer ${raw.id} has neither matchDate nor expiresAt`);
+        }
+        const homeTeam = raw.homeTeam || 'Unknown Team';
+        const awayTeam = raw.awayTeam || 'Unknown Team';
+        const odds = Number(raw.creatorOdds) || 2;
+        const yesProb = (0, utils_1.impliedProbability)(odds);
+        const noProb = (0, utils_1.takerProbability)(odds);
+        const liq = liquidity(raw);
+        const volume24h = (0, utils_1.mistToSui)(raw.totalMatched ?? 0);
+        const marketId = (0, utils_1.toMarketId)(raw.id);
+        const creatorOutcome = {
+            outcomeId: (0, utils_1.toOutcomeId)(raw.id, 'creator'),
+            marketId,
+            label: (0, utils_1.sideLabel)(raw, 'creator'),
+            price: yesProb,
+        };
+        const takerOutcome = {
+            outcomeId: (0, utils_1.toOutcomeId)(raw.id, 'taker'),
+            marketId,
+            label: (0, utils_1.sideLabel)(raw, 'taker'),
+            price: noProb,
+        };
+        const market = {
+            marketId,
+            eventId: raw.matchId ? (0, utils_1.toMarketId)(raw.matchId) : undefined,
+            title: `${raw.matchName || `${homeTeam} vs ${awayTeam}`} \u2014 ${(0, utils_1.sideLabel)(raw, 'creator')} @ ${odds}x`,
+            description: [
+                `P2P offer on ${raw.sport || 'sports'} match.`,
+                `Creator bets ${(0, utils_1.sideLabel)(raw, 'creator')} at ${odds}x odds.`,
+                `Taker backs ${(0, utils_1.sideLabel)(raw, 'taker')} at ${(1 / noProb).toFixed(2)}x implied odds.`,
+                raw.leagueName ? `League: ${raw.leagueName}.` : '',
+                raw.isOnchain ? `On-chain escrow: ${raw.onchainOfferId ?? 'yes'}.` : 'Off-chain escrow.',
+            ].filter(Boolean).join(' '),
+            slug: raw.id,
+            outcomes: [creatorOutcome, takerOutcome],
+            resolutionDate: new Date(dateSource),
+            volume24h,
+            liquidity: liq,
+            url: 'https://suibets.replit.app/p2p',
+            status: (0, utils_1.mapStatus)(raw.status),
+            category: 'Sports',
+            tags: ['Sports', 'P2P', raw.sport, raw.leagueName].filter((t) => Boolean(t)),
+            contractAddress: raw.onchainOfferId,
+            yes: creatorOutcome,
+            no: takerOutcome,
+        };
+        return market;
+    }
+    normalizeEvent(raw) {
+        if (!raw?.id)
+            return null;
+        const homeTeam = raw.homeTeam || 'Unknown Team';
+        const awayTeam = raw.awayTeam || 'Unknown Team';
+        const markets = (raw.offers ?? [])
+            .map(o => this.normalizeMarket(o))
+            .filter((m) => m !== null);
+        const totalVolume = markets.reduce((s, m) => s + (m.volume24h ?? 0), 0);
+        return {
+            id: (0, utils_1.toMarketId)(raw.id),
+            title: raw.name || `${homeTeam} vs ${awayTeam}`,
+            description: [
+                raw.leagueName ? `${raw.leagueName} \u2014` : '',
+                raw.sport,
+                'P2P betting on SuiBets.',
+            ].filter(Boolean).join(' '),
+            slug: raw.id,
+            markets,
+            volume24h: totalVolume,
+            volume: totalVolume,
+            url: 'https://suibets.replit.app/p2p',
+            category: 'Sports',
+            tags: ['Sports', 'P2P', 'Sui', raw.sport, raw.leagueName].filter((t) => Boolean(t)),
+        };
+    }
+    normalizePosition(raw) {
+        const odds = Number(raw.creatorOdds) || 2;
+        return {
+            marketId: (0, utils_1.toMarketId)(raw.matchId ?? raw.id),
+            outcomeId: (0, utils_1.toOutcomeId)(raw.id, 'creator'),
+            outcomeLabel: (0, utils_1.sideLabel)(raw, 'creator'),
+            size: (0, utils_1.mistToSui)(raw.creatorStake ?? 0),
+            entryPrice: (0, utils_1.impliedProbability)(odds),
+            currentPrice: (0, utils_1.impliedProbability)(odds),
+            unrealizedPnL: 0,
+        };
+    }
+}
+exports.SuibetsNormalizer = SuibetsNormalizer;

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

@@ -0,0 +1,63 @@
+/**
+ * Build a unique market ID from a SuiBets offer ID.
+ * Format: "suibets:{offerId}"
+ */
+export declare function toMarketId(offerId: string): string;
+/**
+ * Extract the offer ID from a SuiBets market ID.
+ * Throws if the ID does not carry the expected prefix.
+ */
+export declare function fromMarketId(marketId: string): string;
+/**
+ * Build an outcome ID that encodes both the offer ID and the side.
+ * Format: "{offerId}:{side}"
+ */
+export declare function toOutcomeId(offerId: string, side: 'creator' | 'taker'): string;
+/**
+ * Decode an outcome ID back into offerId and side.
+ * Throws if the format is unrecognised or the side is invalid.
+ */
+export declare function fromOutcomeId(outcomeId: string): {
+    offerId: string;
+    side: 'creator' | 'taker';
+};
+/**
+ * Map raw SuiBets offer statuses to the pmxt unified status vocabulary.
+ *
+ *   OPEN      -> active
+ *   MATCHED   -> matched
+ *   SETTLED   -> settled
+ *   EXPIRED   -> expired
+ *   CANCELLED -> cancelled
+ *   (other)   -> inactive
+ */
+export declare function mapStatus(rawStatus: string): string;
+/**
+ * Convert decimal odds to an implied probability clamped to [0.01, 0.99].
+ *
+ * Throws if odds are zero or negative.
+ * Throws if odds are less than 1 (invalid — a payout below stake).
+ * When odds === 1 (evens), returns 0.99 (clamped maximum).
+ */
+export declare function impliedProbability(decimalOdds: number): number;
+/**
+ * Implied probability for the taker side: 1 - impliedProbability(odds),
+ * clamped to [0.01, 0.99].
+ */
+export declare function takerProbability(decimalOdds: number): number;
+/**
+ * Convert an amount denominated in MIST (the smallest SUI unit, 1e-9 SUI)
+ * to SUI by dividing by 1e9.
+ */
+export declare function mistToSui(mist: number | string): number;
+/**
+ * Return the human-readable team name for the given side of a P2P offer.
+ *
+ * Creator side: the team the creator bet on (creatorTeam, falling back to homeTeam).
+ * Taker side: the opposite team.
+ */
+export declare function sideLabel(offer: {
+    creatorTeam?: string;
+    homeTeam?: string;
+    awayTeam?: string;
+}, side: 'creator' | 'taker'): string;

package/dist/exchanges/suibets/utils.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMarketId = toMarketId;
+exports.fromMarketId = fromMarketId;
+exports.toOutcomeId = toOutcomeId;
+exports.fromOutcomeId = fromOutcomeId;
+exports.mapStatus = mapStatus;
+exports.impliedProbability = impliedProbability;
+exports.takerProbability = takerProbability;
+exports.mistToSui = mistToSui;
+exports.sideLabel = sideLabel;
+const MARKET_PREFIX = 'suibets:';
+/**
+ * Build a unique market ID from a SuiBets offer ID.
+ * Format: "suibets:{offerId}"
+ */
+function toMarketId(offerId) {
+    return `${MARKET_PREFIX}${offerId}`;
+}
+/**
+ * Extract the offer ID from a SuiBets market ID.
+ * Throws if the ID does not carry the expected prefix.
+ */
+function fromMarketId(marketId) {
+    if (!marketId.startsWith(MARKET_PREFIX)) {
+        throw new Error(`Invalid SuiBets market ID: ${marketId}`);
+    }
+    return marketId.slice(MARKET_PREFIX.length);
+}
+/**
+ * Build an outcome ID that encodes both the offer ID and the side.
+ * Format: "{offerId}:{side}"
+ */
+function toOutcomeId(offerId, side) {
+    return `${offerId}:${side}`;
+}
+/**
+ * Decode an outcome ID back into offerId and side.
+ * Throws if the format is unrecognised or the side is invalid.
+ */
+function fromOutcomeId(outcomeId) {
+    const lastColon = outcomeId.lastIndexOf(':');
+    if (lastColon === -1) {
+        throw new Error(`Invalid SuiBets outcome ID: ${outcomeId}`);
+    }
+    const offerId = outcomeId.slice(0, lastColon);
+    const side = outcomeId.slice(lastColon + 1);
+    if (side !== 'creator' && side !== 'taker') {
+        throw new Error(`Invalid side in SuiBets outcome ID: ${outcomeId}`);
+    }
+    if (!offerId) {
+        throw new Error(`Invalid SuiBets outcome ID (empty offerId): ${outcomeId}`);
+    }
+    return { offerId, side };
+}
+/**
+ * Map raw SuiBets offer statuses to the pmxt unified status vocabulary.
+ *
+ *   OPEN      -> active
+ *   MATCHED   -> matched
+ *   SETTLED   -> settled
+ *   EXPIRED   -> expired
+ *   CANCELLED -> cancelled
+ *   (other)   -> inactive
+ */
+function mapStatus(rawStatus) {
+    switch (rawStatus) {
+        case 'OPEN': return 'active';
+        case 'MATCHED': return 'matched';
+        case 'SETTLED': return 'settled';
+        case 'EXPIRED': return 'expired';
+        case 'CANCELLED': return 'cancelled';
+        default: return 'inactive';
+    }
+}
+/**
+ * Convert decimal odds to an implied probability clamped to [0.01, 0.99].
+ *
+ * Throws if odds are zero or negative.
+ * Throws if odds are less than 1 (invalid — a payout below stake).
+ * When odds === 1 (evens), returns 0.99 (clamped maximum).
+ */
+function impliedProbability(decimalOdds) {
+    if (decimalOdds <= 0) {
+        throw new Error(`Decimal odds must be positive, got: ${decimalOdds}`);
+    }
+    if (decimalOdds < 1) {
+        throw new Error(`Decimal odds below 1 are invalid, got: ${decimalOdds}`);
+    }
+    const raw = 1 / decimalOdds;
+    return Math.min(0.99, Math.max(0.01, raw));
+}
+/**
+ * Implied probability for the taker side: 1 - impliedProbability(odds),
+ * clamped to [0.01, 0.99].
+ */
+function takerProbability(decimalOdds) {
+    return Math.min(0.99, Math.max(0.01, 1 - impliedProbability(decimalOdds)));
+}
+/**
+ * Convert an amount denominated in MIST (the smallest SUI unit, 1e-9 SUI)
+ * to SUI by dividing by 1e9.
+ */
+function mistToSui(mist) {
+    return Number(mist) / 1e9;
+}
+/**
+ * Return the human-readable team name for the given side of a P2P offer.
+ *
+ * Creator side: the team the creator bet on (creatorTeam, falling back to homeTeam).
+ * Taker side: the opposite team.
+ */
+function sideLabel(offer, side) {
+    const creator = offer.creatorTeam || offer.homeTeam || 'Home';
+    const away = offer.awayTeam || 'Away';
+    if (side === 'creator')
+        return creator;
+    // Taker takes the opposite side
+    if (creator.toLowerCase() === offer.homeTeam?.toLowerCase())
+        return away;
+    if (creator.toLowerCase() === offer.awayTeam?.toLowerCase())
+        return offer.homeTeam || 'Home';
+    return 'Opposite';
+}

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export * from './exchanges/smarkets';
 export * from './exchanges/polymarket_us';
 export * from './exchanges/hyperliquid';
 export * from './exchanges/gemini-titan';
+export * from './exchanges/suibets';
 export * from './router';
 export * from './feeds';
 export * from './server/app';
@@ -36,6 +37,7 @@ import { SmarketsExchange } from './exchanges/smarkets';
 import { PolymarketUSExchange } from './exchanges/polymarket_us';
 import { HyperliquidExchange } from './exchanges/hyperliquid';
 import { GeminiTitanExchange } from './exchanges/gemini-titan';
+import { SuiBetsExchange } from './exchanges/suibets';
 import { Router } from './router';
 declare const pmxt: {
     Mock: typeof MockExchange;
@@ -52,6 +54,7 @@ declare const pmxt: {
     PolymarketUS: typeof PolymarketUSExchange;
     Hyperliquid: typeof HyperliquidExchange;
     GeminiTitan: typeof GeminiTitanExchange;
+    SuiBets: typeof SuiBetsExchange;
     Router: typeof Router;
 };
 export declare const Mock: typeof MockExchange;
@@ -68,4 +71,5 @@ export declare const Smarkets: typeof SmarketsExchange;
 export declare const PolymarketUS: typeof PolymarketUSExchange;
 export declare const Hyperliquid: typeof HyperliquidExchange;
 export declare const GeminiTitan: typeof GeminiTitanExchange;
+export declare const SuiBets: typeof SuiBetsExchange;
 export default pmxt;

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeminiTitan = exports.Hyperliquid = exports.PolymarketUS = exports.Smarkets = exports.Metaculus = exports.Opinion = exports.Myriad = exports.Baozi = exports.Probable = exports.KalshiDemo = exports.Kalshi = exports.Limitless = exports.Polymarket = exports.Mock = exports.parseOpenApiSpec = void 0;
+exports.SuiBets = exports.GeminiTitan = exports.Hyperliquid = exports.PolymarketUS = exports.Smarkets = exports.Metaculus = exports.Opinion = exports.Myriad = exports.Baozi = exports.Probable = exports.KalshiDemo = exports.Kalshi = exports.Limitless = exports.Polymarket = exports.Mock = exports.parseOpenApiSpec = void 0;
 __exportStar(require("./BaseExchange"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/math"), exports);
@@ -35,6 +35,7 @@ __exportStar(require("./exchanges/smarkets"), exports);
 __exportStar(require("./exchanges/polymarket_us"), exports);
 __exportStar(require("./exchanges/hyperliquid"), exports);
 __exportStar(require("./exchanges/gemini-titan"), exports);
+__exportStar(require("./exchanges/suibets"), exports);
 __exportStar(require("./router"), exports);
 __exportStar(require("./feeds"), exports);
 __exportStar(require("./server/app"), exports);
@@ -54,6 +55,7 @@ const smarkets_1 = require("./exchanges/smarkets");
 const polymarket_us_1 = require("./exchanges/polymarket_us");
 const hyperliquid_1 = require("./exchanges/hyperliquid");
 const gemini_titan_1 = require("./exchanges/gemini-titan");
+const suibets_1 = require("./exchanges/suibets");
 const router_1 = require("./router");
 const pmxt = {
     Mock: mock_1.MockExchange,
@@ -70,6 +72,7 @@ const pmxt = {
     PolymarketUS: polymarket_us_1.PolymarketUSExchange,
     Hyperliquid: hyperliquid_1.HyperliquidExchange,
     GeminiTitan: gemini_titan_1.GeminiTitanExchange,
+    SuiBets: suibets_1.SuiBetsExchange,
     Router: router_1.Router,
 };
 exports.Mock = mock_1.MockExchange;
@@ -86,4 +89,5 @@ exports.Smarkets = smarkets_1.SmarketsExchange;
 exports.PolymarketUS = polymarket_us_1.PolymarketUSExchange;
 exports.Hyperliquid = hyperliquid_1.HyperliquidExchange;
 exports.GeminiTitan = gemini_titan_1.GeminiTitanExchange;
+exports.SuiBets = suibets_1.SuiBetsExchange;
 exports.default = pmxt;