pmxtjs 2.37.14 → 2.39.0

package/dist/generated/src/apis/DefaultApi.js

@@ -994,12 +994,12 @@ class DefaultApi extends runtime.BaseAPI {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError('exchange', 'Required parameter "exchange" was null or undefined when calling fetchOHLCV().');
         }
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling fetchOHLCV().');
+        if (requestParameters['outcomeId'] == null) {
+            throw new runtime.RequiredError('outcomeId', 'Required parameter "outcomeId" was null or undefined when calling fetchOHLCV().');
         }
         const queryParameters = {};
-        if (requestParameters['id'] != null) {
-            queryParameters['id'] = requestParameters['id'];
+        if (requestParameters['outcomeId'] != null) {
+            queryParameters['outcomeId'] = requestParameters['outcomeId'];
         }
         if (requestParameters['resolution'] != null) {
             queryParameters['resolution'] = requestParameters['resolution'];
@@ -1105,12 +1105,12 @@ class DefaultApi extends runtime.BaseAPI {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError('exchange', 'Required parameter "exchange" was null or undefined when calling fetchOrderBook().');
         }
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling fetchOrderBook().');
+        if (requestParameters['outcomeId'] == null) {
+            throw new runtime.RequiredError('outcomeId', 'Required parameter "outcomeId" was null or undefined when calling fetchOrderBook().');
         }
         const queryParameters = {};
-        if (requestParameters['id'] != null) {
-            queryParameters['id'] = requestParameters['id'];
+        if (requestParameters['outcomeId'] != null) {
+            queryParameters['outcomeId'] = requestParameters['outcomeId'];
         }
         if (requestParameters['side'] != null) {
             queryParameters['side'] = requestParameters['side'];
@@ -1237,12 +1237,12 @@ class DefaultApi extends runtime.BaseAPI {
         if (requestParameters['exchange'] == null) {
             throw new runtime.RequiredError('exchange', 'Required parameter "exchange" was null or undefined when calling fetchTrades().');
         }
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling fetchTrades().');
+        if (requestParameters['outcomeId'] == null) {
+            throw new runtime.RequiredError('outcomeId', 'Required parameter "outcomeId" was null or undefined when calling fetchTrades().');
         }
         const queryParameters = {};
-        if (requestParameters['id'] != null) {
-            queryParameters['id'] = requestParameters['id'];
+        if (requestParameters['outcomeId'] != null) {
+            queryParameters['outcomeId'] = requestParameters['outcomeId'];
         }
         if (requestParameters['start'] != null) {
             queryParameters['start'] = requestParameters['start'].toISOString();

package/dist/pmxt/client.d.ts

@@ -5,7 +5,7 @@
  * OpenAPI client, matching the Python API exactly.
  */
 import { Configuration, DefaultApi, ExchangeCredentials } from "../generated/src/index.js";
-import { Balance, BuiltOrder, CreateOrderParams, EventFilterCriteria, EventFilterFunction, ExecutionPriceResult, MarketFilterCriteria, MarketFilterFunction, MarketOutcome, Order, OrderBook, PaginatedMarketsResult, PaginatedEventsResult, Position, PriceCandle, SubscribedAddressSnapshot, SubscriptionOption, Trade, UnifiedEvent, UnifiedMarket, UserTrade } from "./models.js";
+import { Balance, BuiltOrder, CreateOrderParams, EventFetchParams, EventFilterCriteria, EventFilterFunction, ExecutionPriceResult, MarketFetchParams, MarketFilterCriteria, MarketFilterFunction, MarketOutcome, MyTradesParams, Order, OrderBook, OrderHistoryParams, PaginatedMarketsResult, Position, PriceCandle, SubscribedAddressSnapshot, SubscriptionOption, Trade, UnifiedEvent, UnifiedMarket, UserTrade } from "./models.js";
 import { ServerManager } from "./server-manager.js";
 /**
  * Base exchange client options.
@@ -149,29 +149,32 @@ export declare abstract class Exchange {
      */
     protected sidecarReadRequest(methodName: string, query: Record<string, unknown>, args: unknown[]): Promise<any>;
     loadMarkets(reload?: boolean): Promise<Record<string, UnifiedMarket>>;
-    fetchMarkets(params?: any): Promise<UnifiedMarket[]>;
+    fetchMarkets(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     fetchMarketsPaginated(params?: any): Promise<PaginatedMarketsResult>;
-    fetchEvents(params?: any): Promise<UnifiedEvent[]>;
-    fetchEventsPaginated(params?: any): Promise<PaginatedEventsResult>;
-    fetchMarket(params?: any): Promise<UnifiedMarket>;
-    fetchEvent(params?: any): Promise<UnifiedEvent>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchEvents(params?: EventFetchParams): Promise<UnifiedEvent[]>;
+    fetchMarket(params?: MarketFetchParams): Promise<UnifiedMarket>;
+    fetchEvent(params?: EventFetchParams): Promise<UnifiedEvent>;
+    fetchOrderBook(outcomeId: string | MarketOutcome, side?: any): Promise<OrderBook>;
     submitOrder(built: BuiltOrder): Promise<Order>;
     cancelOrder(orderId: string): Promise<Order>;
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
-    fetchMyTrades(params?: any): Promise<UserTrade[]>;
-    fetchClosedOrders(params?: any): Promise<Order[]>;
-    fetchAllOrders(params?: any): Promise<Order[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]>;
+    fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
     fetchPositions(address?: string): Promise<Position[]>;
     fetchBalance(address?: string): Promise<Balance[]>;
-    unwatchOrderBook(id: string): Promise<void>;
+    unwatchOrderBook(outcomeId: string | MarketOutcome): Promise<void>;
     unwatchAddress(address: string): Promise<void>;
+    testDummyMethod(param?: string): Promise<string>;
     close(): Promise<void>;
-    fetchMarketMatches(params: any): Promise<any[]>;
+    fetchMarketMatches(params?: any): Promise<any[]>;
     fetchMatches(params: any): Promise<any[]>;
-    fetchEventMatches(params: any): Promise<any[]>;
+    fetchEventMatches(params?: any): Promise<any[]>;
     compareMarketPrices(params: any): Promise<any[]>;
+    fetchRelatedMarkets(params: any): Promise<any[]>;
+    fetchMatchedMarkets(params?: any): Promise<any[]>;
+    fetchMatchedPrices(params?: any): Promise<any[]>;
     fetchHedges(params: any): Promise<any[]>;
     fetchArbitrage(params?: any): Promise<any[]>;
     /**

package/dist/pmxt/client.js

@@ -69,160 +69,52 @@ function queryHasNestedObject(query) {
 }
 // Converter functions
 function convertMarket(raw) {
-    const outcomes = (raw.outcomes || []).map((o) => ({
-        outcomeId: o.outcomeId,
-        marketId: o.marketId,
-        label: o.label,
-        price: o.price,
-        priceChange24h: o.priceChange24h,
-        metadata: o.metadata,
-    }));
-    const convertOutcome = (o) => o ? ({
-        outcomeId: o.outcomeId,
-        marketId: o.marketId,
-        label: o.label,
-        price: o.price,
-        priceChange24h: o.priceChange24h,
-        metadata: o.metadata,
-    }) : undefined;
     return {
-        marketId: raw.marketId,
-        title: raw.title,
-        slug: raw.slug,
-        outcomes,
-        volume24h: raw.volume24h || 0,
-        liquidity: raw.liquidity || 0,
-        url: raw.url,
-        description: raw.description,
+        ...raw,
         resolutionDate: raw.resolutionDate ? new Date(raw.resolutionDate) : undefined,
-        volume: raw.volume,
-        openInterest: raw.openInterest,
-        image: raw.image,
-        category: raw.category,
-        tags: raw.tags,
-        tickSize: raw.tickSize,
-        status: raw.status,
-        contractAddress: raw.contractAddress,
-        sourceExchange: raw.sourceExchange,
-        eventId: raw.eventId,
-        yes: convertOutcome(raw.yes),
-        no: convertOutcome(raw.no),
-        up: convertOutcome(raw.up),
-        down: convertOutcome(raw.down),
+        outcomes: (raw.outcomes || []).map((o) => ({ ...o })),
+        yes: raw.yes ? { ...raw.yes } : undefined,
+        no: raw.no ? { ...raw.no } : undefined,
+        up: raw.up ? { ...raw.up } : undefined,
+        down: raw.down ? { ...raw.down } : undefined,
     };
 }
 function convertCandle(raw) {
-    return {
-        timestamp: raw.timestamp,
-        open: raw.open,
-        high: raw.high,
-        low: raw.low,
-        close: raw.close,
-        volume: raw.volume,
-    };
+    return { ...raw };
 }
 function convertOrderBook(raw) {
-    const bids = (raw.bids || []).map((b) => ({
-        price: b.price,
-        size: b.size,
-    }));
-    const asks = (raw.asks || []).map((a) => ({
-        price: a.price,
-        size: a.size,
-    }));
     return {
-        bids,
-        asks,
-        timestamp: raw.timestamp,
+        ...raw,
+        bids: (raw.bids || []).map((b) => ({ ...b })),
+        asks: (raw.asks || []).map((a) => ({ ...a })),
     };
 }
 function convertTrade(raw) {
-    return {
-        id: raw.id,
-        timestamp: raw.timestamp,
-        price: raw.price,
-        amount: raw.amount,
-        side: raw.side || "unknown",
-    };
+    return { ...raw, side: raw.side || "unknown" };
 }
 function convertOrder(raw) {
-    return {
-        id: raw.id,
-        marketId: raw.marketId,
-        outcomeId: raw.outcomeId,
-        side: raw.side,
-        type: raw.type,
-        amount: raw.amount,
-        status: raw.status,
-        filled: raw.filled,
-        remaining: raw.remaining,
-        timestamp: raw.timestamp,
-        price: raw.price,
-        fee: raw.fee,
-    };
+    return { ...raw };
 }
 function convertPosition(raw) {
-    return {
-        marketId: raw.marketId,
-        outcomeId: raw.outcomeId,
-        outcomeLabel: raw.outcomeLabel,
-        size: raw.size,
-        entryPrice: raw.entryPrice,
-        currentPrice: raw.currentPrice,
-        unrealizedPnL: raw.unrealizedPnL,
-        realizedPnL: raw.realizedPnL,
-    };
+    return { ...raw };
 }
 function convertBalance(raw) {
-    return {
-        currency: raw.currency,
-        total: raw.total,
-        available: raw.available,
-        locked: raw.locked,
-    };
+    return { ...raw };
 }
 function convertUserTrade(raw) {
-    return {
-        id: raw.id,
-        price: raw.price,
-        amount: raw.amount,
-        side: raw.side || "unknown",
-        timestamp: raw.timestamp,
-        orderId: raw.orderId,
-        outcomeId: raw.outcomeId,
-        marketId: raw.marketId,
-    };
+    return { ...raw, side: raw.side || "unknown" };
 }
 function convertEvent(raw) {
     const markets = models_js_1.MarketList.from((raw.markets || []).map(convertMarket));
-    const event = {
-        id: raw.id,
-        title: raw.title,
-        description: raw.description,
-        slug: raw.slug,
-        markets,
-        volume24h: raw.volume24h,
-        volume: raw.volume,
-        url: raw.url,
-        image: raw.image,
-        category: raw.category,
-        tags: raw.tags,
-        sourceExchange: raw.sourceExchange,
-    };
-    return event;
+    return { ...raw, markets };
 }
 function convertSubscriptionSnapshot(raw) {
-    const trades = (raw.trades ?? []).map(convertTrade);
-    const balances = (raw.balances ?? []).map(convertBalance);
-    const positions = (raw.positions ?? []).map(convertPosition);
-    const snapShot = {
-        address: raw.address,
-        trades,
-        balances,
-        positions,
-        timestamp: raw.timestamp,
+    return {
+        ...raw,
+        trades: (raw.trades ?? []).map(convertTrade),
+        balances: (raw.balances ?? []).map(convertBalance),
+        positions: (raw.positions ?? []).map(convertPosition),
     };
-    return snapShot;
 }
 /**
  * Base class for prediction market exchanges.
@@ -671,38 +563,6 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to fetchEvents: ${error}`);
         }
     }
-    async fetchEventsPaginated(params) {
-        await this.initPromise;
-        try {
-            const args = [];
-            if (params !== undefined)
-                args.push(params);
-            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchEventsPaginated`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
-                body: JSON.stringify({ args, credentials: this.getCredentials() }),
-            });
-            if (!response.ok) {
-                const body = await response.json().catch(() => ({}));
-                if (body.error && typeof body.error === "object") {
-                    throw (0, errors_js_1.fromServerError)(body.error);
-                }
-                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
-            }
-            const json = await response.json();
-            const data = this.handleResponse(json);
-            return {
-                data: (data.data || []).map(convertEvent),
-                total: data.total,
-                nextCursor: data.nextCursor,
-            };
-        }
-        catch (error) {
-            if (error instanceof errors_js_1.PmxtError)
-                throw error;
-            throw new errors_js_1.PmxtError(`Failed to fetchEventsPaginated: ${error}`);
-        }
-    }
     async fetchMarket(params) {
         await this.initPromise;
         try {
@@ -759,11 +619,13 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to fetchEvent: ${error}`);
         }
     }
-    async fetchOrderBook(id) {
+    async fetchOrderBook(outcomeId, side) {
         await this.initPromise;
         try {
             const args = [];
-            args.push(id);
+            args.push(resolveOutcomeId(outcomeId));
+            if (side !== undefined)
+                args.push(side);
             const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchOrderBook`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -787,11 +649,6 @@ class Exchange {
         }
     }
     async submitOrder(built) {
-        if (this.isHosted) {
-            throw new errors_js_1.PmxtError("Trade execution is not available through the hosted API. " +
-                "Use the local PMXT SDK with your venue credentials instead. " +
-                "See https://pmxt.dev/docs/quickstart for setup instructions.");
-        }
         await this.initPromise;
         try {
             const args = [];
@@ -819,11 +676,6 @@ class Exchange {
         }
     }
     async cancelOrder(orderId) {
-        if (this.isHosted) {
-            throw new errors_js_1.PmxtError("Trade execution is not available through the hosted API. " +
-                "Use the local PMXT SDK with your venue credentials instead. " +
-                "See https://pmxt.dev/docs/quickstart for setup instructions.");
-        }
         await this.initPromise;
         try {
             const args = [];
@@ -1045,11 +897,11 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to fetchBalance: ${error}`);
         }
     }
-    async unwatchOrderBook(id) {
+    async unwatchOrderBook(outcomeId) {
         await this.initPromise;
         try {
             const args = [];
-            args.push(id);
+            args.push(resolveOutcomeId(outcomeId));
             const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/unwatchOrderBook`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -1097,6 +949,33 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to unwatchAddress: ${error}`);
         }
     }
+    async testDummyMethod(param) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (param !== undefined)
+                args.push(param);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/testDummyMethod`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const body = await response.json().catch(() => ({}));
+                if (body.error && typeof body.error === "object") {
+                    throw (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to testDummyMethod: ${error}`);
+        }
+    }
     async close() {
         await this.initPromise;
         try {
@@ -1126,7 +1005,8 @@ class Exchange {
         await this.initPromise;
         try {
             const args = [];
-            args.push(params);
+            if (params !== undefined)
+                args.push(params);
             const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchMarketMatches`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -1178,7 +1058,8 @@ class Exchange {
         await this.initPromise;
         try {
             const args = [];
-            args.push(params);
+            if (params !== undefined)
+                args.push(params);
             const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchEventMatches`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -1226,6 +1107,86 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to compareMarketPrices: ${error}`);
         }
     }
+    async fetchRelatedMarkets(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            args.push(params);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchRelatedMarkets`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const body = await response.json().catch(() => ({}));
+                if (body.error && typeof body.error === "object") {
+                    throw (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchRelatedMarkets: ${error}`);
+        }
+    }
+    async fetchMatchedMarkets(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchMatchedMarkets`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const body = await response.json().catch(() => ({}));
+                if (body.error && typeof body.error === "object") {
+                    throw (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchMatchedMarkets: ${error}`);
+        }
+    }
+    async fetchMatchedPrices(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params !== undefined)
+                args.push(params);
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchMatchedPrices`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const body = await response.json().catch(() => ({}));
+                if (body.error && typeof body.error === "object") {
+                    throw (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to fetchMatchedPrices: ${error}`);
+        }
+    }
     async fetchHedges(params) {
         await this.initPromise;
         try {

package/dist/pmxt/models.d.ts

@@ -266,8 +266,24 @@ export interface MarketFilterParams {
     offset?: number;
     /** Sort order */
     sort?: SortOption;
+    /** Filter by market status (default: 'active') */
+    status?: 'active' | 'inactive' | 'closed' | 'all';
     /** Where to search (for filterMarkets) */
     searchIn?: SearchIn;
+    /** Keyword search query */
+    query?: string;
+    /** Slug/ticker lookup */
+    slug?: string;
+    /** Direct lookup by market ID */
+    marketId?: string;
+    /** Reverse lookup -- find market containing this outcome */
+    outcomeId?: string;
+    /** Find markets belonging to an event */
+    eventId?: string;
+    /** Pagination page (used by Limitless) */
+    page?: number;
+    /** Semantic search threshold (used by Limitless) */
+    similarityThreshold?: number;
     /** Filter by market category (e.g. "sports", "politics", "crypto") */
     category?: string;
     /** Filter by tags attached to the market */
@@ -334,6 +350,64 @@ export interface CreateOrderParams {
     /** Optional fee rate (e.g., 1000 for 0.1%) */
     fee?: number;
 }
+/** Alias matching the core MarketFetchParams name. */
+export type MarketFetchParams = MarketFilterParams;
+/**
+ * Parameters for fetching OHLCV candle data.
+ */
+export interface OHLCVParams {
+    /** Candle resolution (e.g. '1m', '5m', '1h', '1d') */
+    resolution: CandleInterval;
+    /** Start of the time range */
+    start?: Date;
+    /** End of the time range */
+    end?: Date;
+    /** Maximum number of candles */
+    limit?: number;
+}
+/**
+ * Parameters for fetching public trades.
+ */
+export interface TradesParams {
+    /** Start of the time range */
+    start?: Date;
+    /** End of the time range */
+    end?: Date;
+    /** Maximum number of results */
+    limit?: number;
+}
+/**
+ * Parameters for fetching the authenticated user's trade history.
+ */
+export interface MyTradesParams {
+    /** Filter by outcome ID */
+    outcomeId?: string;
+    /** Filter by market ID */
+    marketId?: string;
+    /** Only return records after this date */
+    since?: Date;
+    /** Only return records before this date */
+    until?: Date;
+    /** Maximum number of results */
+    limit?: number;
+    /** Cursor for pagination */
+    cursor?: string;
+}
+/**
+ * Parameters for fetching closed/all order history.
+ */
+export interface OrderHistoryParams {
+    /** Filter by market ID */
+    marketId?: string;
+    /** Only return records after this date */
+    since?: Date;
+    /** Only return records before this date */
+    until?: Date;
+    /** Maximum number of results */
+    limit?: number;
+    /** Cursor for pagination */
+    cursor?: string;
+}
 /**
  * An order payload built but not yet submitted to the exchange.
  */