pmxt-core 2.44.5 → 2.45.0

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;

package/dist/router/Router.js

@@ -217,7 +217,10 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
         }
         // Lookup mode: find matches for a specific market.
         const response = await this.client.getMarketMatches(params);
-        const matches = response.matches ?? [];
+        if (!response || !Array.isArray(response.matches)) {
+            throw new Error('fetchMarketMatches returned an unexpected response shape: missing matches array');
+        }
+        const matches = response.matches;
         return matches.map((m) => ({
             market: m.market,
             relation: m.relation,
@@ -262,14 +265,20 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
         const hasIdentifier = params.eventId || params.slug;
         if (!hasIdentifier) {
             const results = await this.client.browseEventMatches(params);
-            return Array.isArray(results) ? results : [];
+            if (!Array.isArray(results)) {
+                throw new Error(`browseEventMatches returned unexpected type '${typeof results}'`);
+            }
+            return results;
         }
         if (await this.resolveLocalMockEventLookup(params)) {
             return [];
         }
         // Lookup mode: find matches for a specific event.
         const response = await this.client.getEventMatches(params);
-        return response.matches ?? [];
+        if (!response || !Array.isArray(response.matches)) {
+            throw new Error('fetchEventMatches returned an unexpected response shape: missing matches array');
+        }
+        return response.matches;
     }
     // -----------------------------------------------------------------------
     // Price comparison: identity matches with live prices

package/dist/server/app.js

@@ -134,6 +134,80 @@ function queryToArgs(query, spec) {
     }
     return args;
 }
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function toDateParam(value, field, exchange) {
+    if (value instanceof Date) {
+        if (Number.isNaN(value.getTime())) {
+            throw new errors_1.ValidationError(`${field} must be a valid date-time value.`, field, exchange);
+        }
+        return value;
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        const parsed = new Date(value);
+        if (!Number.isNaN(parsed.getTime())) {
+            return parsed;
+        }
+    }
+    throw new errors_1.ValidationError(`${field} must be a valid date-time string or timestamp.`, field, exchange);
+}
+function normalizeDateFields(params, fields, exchange) {
+    const normalized = { ...params };
+    for (const field of fields) {
+        const value = normalized[field];
+        if (value === undefined || value === null || value === "")
+            continue;
+        normalized[field] = toDateParam(value, field, exchange);
+    }
+    return normalized;
+}
+function isMissing(value) {
+    return value === undefined || value === null || value === "";
+}
+function assertFiniteNumber(params, field, exchange) {
+    const value = params[field];
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new errors_1.ValidationError(`createOrder params.${field} must be a finite number.`, field, exchange);
+    }
+}
+function validateCreateOrderParams(params, exchange) {
+    if (!isRecord(params)) {
+        throw new errors_1.ValidationError("createOrder requires an order parameter object.", "params", exchange);
+    }
+    const required = ["marketId", "outcomeId", "side", "type", "amount"];
+    const missing = required.filter((field) => isMissing(params[field]));
+    if (missing.length > 0) {
+        throw new errors_1.ValidationError(`createOrder requires ${missing.map((field) => `params.${field}`).join(", ")}.`, missing[0], exchange);
+    }
+    if (params.side !== "buy" && params.side !== "sell") {
+        throw new errors_1.ValidationError('createOrder params.side must be "buy" or "sell".', "side", exchange);
+    }
+    if (params.type !== "market" && params.type !== "limit") {
+        throw new errors_1.ValidationError('createOrder params.type must be "market" or "limit".', "type", exchange);
+    }
+    assertFiniteNumber(params, "amount", exchange);
+    if (params.type === "limit" && isMissing(params.price)) {
+        throw new errors_1.ValidationError("createOrder params.price is required for limit orders.", "price", exchange);
+    }
+    if (!isMissing(params.price)) {
+        assertFiniteNumber(params, "price", exchange);
+    }
+    if (!isMissing(params.fee)) {
+        assertFiniteNumber(params, "fee", exchange);
+    }
+    return params;
+}
+function normalizeDispatchArgs(methodName, args, exchange) {
+    const normalized = [...args];
+    if (methodName === "fetchOHLCV" && isRecord(normalized[1])) {
+        normalized[1] = normalizeDateFields(normalized[1], ["start", "end"], exchange);
+    }
+    if (methodName === "createOrder") {
+        normalized[0] = validateCreateOrderParams(normalized[0], exchange);
+    }
+    return normalized;
+}
 // Singleton instances for local usage (when no credentials provided)
 const defaultExchanges = {
     polymarket: null,
@@ -275,7 +349,8 @@ function createApp(options = {}) {
                 });
                 return;
             }
-            const result = await exchange[methodName](...args);
+            const normalizedArgs = normalizeDispatchArgs(methodName, args, exchangeName);
+            const result = await exchange[methodName](...normalizedArgs);
             res.json({ success: true, data: result });
         }
         catch (error) {

package/dist/server/exchange-factory.js

@@ -14,6 +14,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 mock_1 = require("../exchanges/mock");
 const router_1 = require("../router");
 function createExchange(name, credentials, bearerToken) {
@@ -103,6 +104,11 @@ function createExchange(name, credentials, bearerToken) {
                 apiKey: credentials?.apiKey || process.env.GEMINI_API_KEY,
                 apiSecret: credentials?.apiSecret || process.env.GEMINI_API_SECRET,
             });
+        case "suibets":
+            return new suibets_1.SuiBetsExchange({
+                walletAddress: credentials?.walletAddress || process.env.SUIBETS_WALLET_ADDRESS,
+                baseUrl: credentials?.baseUrl || process.env.SUIBETS_BASE_URL,
+            });
         case "mock":
             return new mock_1.MockExchange();
         case "router":

package/dist/server/openapi.yaml

@@ -4159,6 +4159,13 @@ x-sdk-constructors:
         tsName: apiSecret
         type: string
         description: API secret for authentication
+  suibets:
+    className: Suibets
+    params:
+      - name: pmxt_api_key
+        tsName: pmxtApiKey
+        type: string
+        description: PMXT API key for hosted access
   mock:
     className: Mock
     params: