@polymarket/clob-client-v2 1.0.8 → 1.1.1-canary.0

package/dist/client.d.cts

@@ -1,6 +1,6 @@
 import { ClobSigner } from "./signing/signer.cjs";
 import { Side } from "./order-utils/model/side.cjs";
-import { ApiKeyCreds, ApiKeysResponse, BalanceAllowanceParams, BalanceAllowanceResponse, BanStatus, BookParams, BuilderApiKey, BuilderApiKeyResponse, BuilderConfig, BuilderFeeRates, BuilderTradeParams, BuilderTradesResponse, Chain, CreateOrderOptions, DropNotificationParams, FeeInfos, FeeRates, MarketDetails, MarketPrice, MarketReward, MarketTradeEvent, NegRisk, Notification, OpenOrder, OpenOrderParams, OpenOrdersResponse, OrderBookSummary, OrderMarketCancelParams, OrderPayload, OrderScoring, OrderScoringParams, OrderType, OrdersScoring, OrdersScoringParams, PaginationPayload, PreMigrationOrdersResponse, PriceHistoryFilterParams, ReadonlyApiKeyResponse, RewardsPercentages, TickSize, TickSizes, TotalUserEarning, Trade, TradeParams, TradesPaginatedResponse, UserEarning, UserRewardsEarning } from "./types/clob.cjs";
+import { ApiKeyCreds, ApiKeysResponse, BalanceAllowanceParams, BalanceAllowanceResponse, BanStatus, BookParams, BuilderApiKey, BuilderApiKeyResponse, BuilderConfig, BuilderFeeRates, BuilderTradeParams, BuilderTradesResponse, Chain, CreateOrderOptions, DropNotificationParams, FeeInfos, FeeRates, MarketDetails, MarketPrice, MarketReward, MarketTradeEvent, NegRisk, Notification, OpenOrder, OpenOrderParams, OpenOrdersResponse, OrderBookSummary, OrderMarketCancelParams, OrderPayload, OrderResponse, OrderScoring, OrderScoringParams, OrderType, OrdersScoring, OrdersScoringParams, PaginationPayload, PreMigrationOrdersResponse, PriceHistoryFilterParams, ReadonlyApiKeyResponse, RewardsPercentages, TickSize, TickSizes, TotalUserEarning, Trade, TradeParams, TradesPaginatedResponse, UserEarning, UserRewardsEarning } from "./types/clob.cjs";
 import { UserMarketOrderV1, UserOrderV1 } from "./types/ordersV1.cjs";
 import { UserMarketOrderV2, UserOrderV2 } from "./types/ordersV2.cjs";
 import { ExchangeV3OrderAmounts } from "./types/ordersV3.cjs";
@@ -41,6 +41,8 @@ declare class ClobClient {
   readonly signatureType: SignatureTypeV2;
   readonly funderAddress?: string;
   private cachedVersion?;
+  private versionRequest?;
+  private readonly marketInfoRequests;
   readonly retryOnError?: boolean;
   readonly throwOnError?: boolean;
   readonly feeSlippage: number;
@@ -63,14 +65,28 @@ declare class ClobClient {
     heartbeat_id: string;
     error_msg?: string;
   }>;
+  /**
+   * Fetches the current order version from the server and adopts it for the
+   * orders this client signs afterwards. Joins a version request that is
+   * already in flight. An error response yields the default version 2, which
+   * the first order corrects through the order version mismatch recovery.
+   * Throws ApiError when the client was created with throwOnError.
+   */
   getVersion(): Promise<number>;
+  private startVersionRequest;
   getServerTime(): Promise<number>;
   getSamplingSimplifiedMarkets(next_cursor?: string): Promise<PaginationPayload>;
   getSamplingMarkets(next_cursor?: string): Promise<PaginationPayload>;
   getSimplifiedMarkets(next_cursor?: string): Promise<PaginationPayload>;
   getMarkets(next_cursor?: string): Promise<PaginationPayload>;
   getMarket(conditionID: string): Promise<any>;
+  /**
+   * Fetches the market parameters for a condition and caches the tick size,
+   * neg-risk flag, and fee details of both outcomes for later orders. Every
+   * call refreshes the caches. Concurrent calls for a condition share one request.
+   */
   getClobMarketInfo(conditionID: string): Promise<MarketDetails>;
+  private fetchClobMarketInfo;
   getOrderBook(tokenID: string): Promise<OrderBookSummary>;
   getOrderBooks(params: BookParams[]): Promise<OrderBookSummary[]>;
   getTickSize(tokenID: string): Promise<TickSize>;
@@ -122,12 +138,22 @@ declare class ClobClient {
   createOrder(userOrder: UserOrderV1 | UserOrderV2, options?: Partial<CreateOrderOptions>): Promise<SignedOrder>;
   createMarketOrder(userMarketOrder: UserMarketOrderV1 | UserMarketOrderV2, options?: Partial<CreateOrderOptions>): Promise<SignedOrder>;
   createExchangeV3OrderFromAmounts(userOrder: ExchangeV3OrderAmounts): Promise<SignedOrder>;
-  createAndPostOrder<T extends OrderType.GTC | OrderType.GTD = OrderType.GTC>(userOrder: UserOrderV1 | UserOrderV2, options?: Partial<CreateOrderOptions>, orderType?: T, postOnly?: boolean, deferExec?: boolean): Promise<any>;
-  createAndPostMarketOrder<T extends OrderType.FOK | OrderType.FAK = OrderType.FOK>(userMarketOrder: UserMarketOrderV1 | UserMarketOrderV2, options?: Partial<CreateOrderOptions>, orderType?: T, deferExec?: boolean): Promise<any>;
+  createAndPostOrder<T extends OrderType.GTC | OrderType.GTD = OrderType.GTC>(userOrder: UserOrderV1 | UserOrderV2, options?: Partial<CreateOrderOptions>, orderType?: T, postOnly?: boolean, deferExec?: boolean): Promise<OrderResponse>;
+  createAndPostMarketOrder<T extends OrderType.FOK | OrderType.FAK = OrderType.FOK>(userMarketOrder: UserMarketOrderV1 | UserMarketOrderV2, options?: Partial<CreateOrderOptions>, orderType?: T, deferExec?: boolean): Promise<OrderResponse>;
   getOpenOrders(params?: OpenOrderParams, only_first_page?: boolean, next_cursor?: string): Promise<OpenOrdersResponse>;
   getPreMigrationOrders(only_first_page?: boolean, next_cursor?: string): Promise<PreMigrationOrdersResponse>;
-  postOrder<T extends OrderType = OrderType.GTC>(order: SignedOrder, orderType?: T, postOnly?: boolean, deferExec?: boolean): Promise<any>;
-  postOrders(args: PostOrdersArgs[], postOnly?: boolean, deferExec?: boolean): Promise<any>;
+  /**
+   * Posts an order to the CLOB.
+   *
+   * When the order matches, the response carries the settlement transaction
+   * hashes of its fills in `transactionsHashes`, resolved on a best-effort
+   * basis. If a hash is not available yet, the fill's trade can be followed
+   * via `tradeIDs`.
+   */
+  postOrder<T extends OrderType = OrderType.GTC>(order: SignedOrder, orderType?: T, postOnly?: boolean, deferExec?: boolean): Promise<OrderResponse>;
+  postOrders(args: PostOrdersArgs[], postOnly?: boolean, deferExec?: boolean): Promise<OrderResponse[]>;
+  private waitForResolvedTrades;
+  private resolveTransactionsHashes;
   cancelOrder(payload: OrderPayload): Promise<any>;
   cancelOrders(ordersHashes: string[]): Promise<any>;
   cancelAll(): Promise<any>;

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import { ClobSigner } from "./signing/signer.js";
 import { Side } from "./order-utils/model/side.js";
-import { ApiKeyCreds, ApiKeysResponse, BalanceAllowanceParams, BalanceAllowanceResponse, BanStatus, BookParams, BuilderApiKey, BuilderApiKeyResponse, BuilderConfig, BuilderFeeRates, BuilderTradeParams, BuilderTradesResponse, Chain, CreateOrderOptions, DropNotificationParams, FeeInfos, FeeRates, MarketDetails, MarketPrice, MarketReward, MarketTradeEvent, NegRisk, Notification, OpenOrder, OpenOrderParams, OpenOrdersResponse, OrderBookSummary, OrderMarketCancelParams, OrderPayload, OrderScoring, OrderScoringParams, OrderType, OrdersScoring, OrdersScoringParams, PaginationPayload, PreMigrationOrdersResponse, PriceHistoryFilterParams, ReadonlyApiKeyResponse, RewardsPercentages, TickSize, TickSizes, TotalUserEarning, Trade, TradeParams, TradesPaginatedResponse, UserEarning, UserRewardsEarning } from "./types/clob.js";
+import { ApiKeyCreds, ApiKeysResponse, BalanceAllowanceParams, BalanceAllowanceResponse, BanStatus, BookParams, BuilderApiKey, BuilderApiKeyResponse, BuilderConfig, BuilderFeeRates, BuilderTradeParams, BuilderTradesResponse, Chain, CreateOrderOptions, DropNotificationParams, FeeInfos, FeeRates, MarketDetails, MarketPrice, MarketReward, MarketTradeEvent, NegRisk, Notification, OpenOrder, OpenOrderParams, OpenOrdersResponse, OrderBookSummary, OrderMarketCancelParams, OrderPayload, OrderResponse, OrderScoring, OrderScoringParams, OrderType, OrdersScoring, OrdersScoringParams, PaginationPayload, PreMigrationOrdersResponse, PriceHistoryFilterParams, ReadonlyApiKeyResponse, RewardsPercentages, TickSize, TickSizes, TotalUserEarning, Trade, TradeParams, TradesPaginatedResponse, UserEarning, UserRewardsEarning } from "./types/clob.js";
 import { UserMarketOrderV1, UserOrderV1 } from "./types/ordersV1.js";
 import { UserMarketOrderV2, UserOrderV2 } from "./types/ordersV2.js";
 import { ExchangeV3OrderAmounts } from "./types/ordersV3.js";
@@ -43,6 +43,8 @@ declare class ClobClient {
   readonly signatureType: SignatureTypeV2;
   readonly funderAddress?: string;
   private cachedVersion?;
+  private versionRequest?;
+  private readonly marketInfoRequests;
   readonly retryOnError?: boolean;
   readonly throwOnError?: boolean;
   readonly feeSlippage: number;
@@ -65,14 +67,28 @@ declare class ClobClient {
     heartbeat_id: string;
     error_msg?: string;
   }>;
+  /**
+   * Fetches the current order version from the server and adopts it for the
+   * orders this client signs afterwards. Joins a version request that is
+   * already in flight. An error response yields the default version 2, which
+   * the first order corrects through the order version mismatch recovery.
+   * Throws ApiError when the client was created with throwOnError.
+   */
   getVersion(): Promise<number>;
+  private startVersionRequest;
   getServerTime(): Promise<number>;
   getSamplingSimplifiedMarkets(next_cursor?: string): Promise<PaginationPayload>;
   getSamplingMarkets(next_cursor?: string): Promise<PaginationPayload>;
   getSimplifiedMarkets(next_cursor?: string): Promise<PaginationPayload>;
   getMarkets(next_cursor?: string): Promise<PaginationPayload>;
   getMarket(conditionID: string): Promise<any>;
+  /**
+   * Fetches the market parameters for a condition and caches the tick size,
+   * neg-risk flag, and fee details of both outcomes for later orders. Every
+   * call refreshes the caches. Concurrent calls for a condition share one request.
+   */
   getClobMarketInfo(conditionID: string): Promise<MarketDetails>;
+  private fetchClobMarketInfo;
   getOrderBook(tokenID: string): Promise<OrderBookSummary>;
   getOrderBooks(params: BookParams[]): Promise<OrderBookSummary[]>;
   getTickSize(tokenID: string): Promise<TickSize>;
@@ -124,12 +140,22 @@ declare class ClobClient {
   createOrder(userOrder: UserOrderV1 | UserOrderV2, options?: Partial<CreateOrderOptions>): Promise<SignedOrder>;
   createMarketOrder(userMarketOrder: UserMarketOrderV1 | UserMarketOrderV2, options?: Partial<CreateOrderOptions>): Promise<SignedOrder>;
   createExchangeV3OrderFromAmounts(userOrder: ExchangeV3OrderAmounts): Promise<SignedOrder>;
-  createAndPostOrder<T extends OrderType.GTC | OrderType.GTD = OrderType.GTC>(userOrder: UserOrderV1 | UserOrderV2, options?: Partial<CreateOrderOptions>, orderType?: T, postOnly?: boolean, deferExec?: boolean): Promise<any>;
-  createAndPostMarketOrder<T extends OrderType.FOK | OrderType.FAK = OrderType.FOK>(userMarketOrder: UserMarketOrderV1 | UserMarketOrderV2, options?: Partial<CreateOrderOptions>, orderType?: T, deferExec?: boolean): Promise<any>;
+  createAndPostOrder<T extends OrderType.GTC | OrderType.GTD = OrderType.GTC>(userOrder: UserOrderV1 | UserOrderV2, options?: Partial<CreateOrderOptions>, orderType?: T, postOnly?: boolean, deferExec?: boolean): Promise<OrderResponse>;
+  createAndPostMarketOrder<T extends OrderType.FOK | OrderType.FAK = OrderType.FOK>(userMarketOrder: UserMarketOrderV1 | UserMarketOrderV2, options?: Partial<CreateOrderOptions>, orderType?: T, deferExec?: boolean): Promise<OrderResponse>;
   getOpenOrders(params?: OpenOrderParams, only_first_page?: boolean, next_cursor?: string): Promise<OpenOrdersResponse>;
   getPreMigrationOrders(only_first_page?: boolean, next_cursor?: string): Promise<PreMigrationOrdersResponse>;
-  postOrder<T extends OrderType = OrderType.GTC>(order: SignedOrder, orderType?: T, postOnly?: boolean, deferExec?: boolean): Promise<any>;
-  postOrders(args: PostOrdersArgs[], postOnly?: boolean, deferExec?: boolean): Promise<any>;
+  /**
+   * Posts an order to the CLOB.
+   *
+   * When the order matches, the response carries the settlement transaction
+   * hashes of its fills in `transactionsHashes`, resolved on a best-effort
+   * basis. If a hash is not available yet, the fill's trade can be followed
+   * via `tradeIDs`.
+   */
+  postOrder<T extends OrderType = OrderType.GTC>(order: SignedOrder, orderType?: T, postOnly?: boolean, deferExec?: boolean): Promise<OrderResponse>;
+  postOrders(args: PostOrdersArgs[], postOnly?: boolean, deferExec?: boolean): Promise<OrderResponse[]>;
+  private waitForResolvedTrades;
+  private resolveTransactionsHashes;
   cancelOrder(payload: OrderPayload): Promise<any>;
   cancelOrders(ordersHashes: string[]): Promise<any>;
   cancelAll(): Promise<any>;

package/dist/client.js

@@ -17,6 +17,11 @@ import { ROUNDING_CONFIG } from "./order-builder/helpers/roundingConfig.js";
 import { OrderBuilder } from "./order-builder/orderBuilder.js";
 
 //#region src/client.ts
+const RESOLVE_TRADES_TIMEOUT_MS = 3e4;
+const RESOLVE_TRADES_POLL_INTERVAL_MS = 250;
+const FAILED_TRADE_STATUS = "FAILED";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const isTradeResolved = (trade) => trade.status.toUpperCase() === FAILED_TRADE_STATUS || Boolean(trade.transaction_hash && trade.transaction_hash.length > 0);
 var ClobClient = class {
 	host;
 	chainId;
@@ -34,6 +39,8 @@ var ClobClient = class {
 	signatureType;
 	funderAddress;
 	cachedVersion;
+	versionRequest;
+	marketInfoRequests = /* @__PURE__ */ new Map();
 	retryOnError;
 	throwOnError;
 	feeSlippage;
@@ -74,8 +81,26 @@ var ClobClient = class {
 			data: { heartbeat_id: heartbeatId }
 		});
 	}
+	/**
+	* Fetches the current order version from the server and adopts it for the
+	* orders this client signs afterwards. Joins a version request that is
+	* already in flight. An error response yields the default version 2, which
+	* the first order corrects through the order version mismatch recovery.
+	* Throws ApiError when the client was created with throwOnError.
+	*/
 	async getVersion() {
-		return (await this.get(`${this.host}/version`))?.version ?? 2;
+		return this.versionRequest ?? this.startVersionRequest();
+	}
+	startVersionRequest() {
+		const request = this.get(`${this.host}/version`).then((response) => {
+			const version = response?.version ?? 2;
+			this.cachedVersion = version;
+			return version;
+		}).finally(() => {
+			if (this.versionRequest === request) this.versionRequest = void 0;
+		});
+		this.versionRequest = request;
+		return request;
 	}
 	async getServerTime() {
 		return this.get(`${this.host}${TIME}`);
@@ -95,7 +120,23 @@ var ClobClient = class {
 	async getMarket(conditionID) {
 		return this.get(`${this.host}${GET_MARKET}${conditionID}`);
 	}
+	/**
+	* Fetches the market parameters for a condition and caches the tick size,
+	* neg-risk flag, and fee details of both outcomes for later orders. Every
+	* call refreshes the caches. Concurrent calls for a condition share one request.
+	*/
 	async getClobMarketInfo(conditionID) {
+		const pending = this.marketInfoRequests.get(conditionID);
+		if (pending) return pending;
+		const request = this.fetchClobMarketInfo(conditionID);
+		this.marketInfoRequests.set(conditionID, request);
+		try {
+			return await request;
+		} finally {
+			this.marketInfoRequests.delete(conditionID);
+		}
+	}
+	async fetchClobMarketInfo(conditionID) {
 		const result = await this.get(`${this.host}${GET_CLOB_MARKET}${conditionID}`);
 		if (!result?.t) throw new Error(`failed to fetch market info for condition id ${conditionID}`);
 		for (const token of result.t) {
@@ -472,20 +513,16 @@ var ClobClient = class {
 		return this.orderBuilder.buildExchangeV3OrderFromAmounts(orderToSign);
 	}
 	async createAndPostOrder(userOrder, options, orderType = OrderType.GTC, postOnly = false, deferExec = false) {
-		let postOrderResponse;
-		await this._retryOnVersionUpdate(async () => {
+		return this._retryOnVersionUpdate(async () => {
 			const order = await this.createOrder(userOrder, options);
-			postOrderResponse = await this.postOrder(order, orderType, postOnly, deferExec);
+			return this.postOrder(order, orderType, postOnly, deferExec);
 		});
-		return postOrderResponse;
 	}
 	async createAndPostMarketOrder(userMarketOrder, options, orderType = OrderType.FOK, deferExec = false) {
-		let postOrderMarketResponse;
-		await this._retryOnVersionUpdate(async () => {
+		return this._retryOnVersionUpdate(async () => {
 			const order = await this.createMarketOrder(userMarketOrder, options);
-			postOrderMarketResponse = await this.postOrder(order, orderType, false, deferExec);
+			return this.postOrder(order, orderType, false, deferExec);
 		});
-		return postOrderMarketResponse;
 	}
 	async getOpenOrders(params, only_first_page = false, next_cursor) {
 		this.canL2Auth();
@@ -532,6 +569,14 @@ var ClobClient = class {
 		}
 		return results;
 	}
+	/**
+	* Posts an order to the CLOB.
+	*
+	* When the order matches, the response carries the settlement transaction
+	* hashes of its fills in `transactionsHashes`, resolved on a best-effort
+	* basis. If a hash is not available yet, the fill's trade can be followed
+	* via `tradeIDs`.
+	*/
 	async postOrder(order, orderType = OrderType.GTC, postOnly = false, deferExec = false) {
 		this.canL2Auth();
 		if (postOnly && (orderType === OrderType.FOK || orderType === OrderType.FAK)) throw new Error("postOnly is not supported for FOK/FAK orders");
@@ -548,7 +593,9 @@ var ClobClient = class {
 			data: orderPayload
 		}, true);
 		if (this._isOrderVersionMismatch(res)) await this.resolveVersion(true);
-		return this.throwIfError(res);
+		const response = this.throwIfError(res);
+		if (deferExec) return response;
+		return this.resolveTransactionsHashes(response);
 	}
 	async postOrders(args, postOnly = false, deferExec = false) {
 		this.canL2Auth();
@@ -571,7 +618,34 @@ var ClobClient = class {
 			data: ordersPayload
 		}, true);
 		if (this._isOrderVersionMismatch(res)) await this.resolveVersion(true);
-		return this.throwIfError(res);
+		const responses = this.throwIfError(res);
+		if (deferExec || !Array.isArray(responses)) return responses;
+		return Promise.all(responses.map((response) => this.resolveTransactionsHashes(response)));
+	}
+	async waitForResolvedTrades(tradeIDs) {
+		const ids = [...new Set(tradeIDs.filter((id) => id.length > 0))];
+		if (ids.length === 0) return [];
+		const resolved = /* @__PURE__ */ new Map();
+		const requestedIDs = new Set(ids);
+		const deadline = Date.now() + RESOLVE_TRADES_TIMEOUT_MS;
+		for (;;) {
+			const pending = ids.filter((id) => !resolved.has(id));
+			const pages = await Promise.all(pending.map((id) => this.getTrades({ id }, true).catch(() => [])));
+			for (const trades of pages) for (const trade of trades) if (isTradeResolved(trade) && requestedIDs.has(trade.id)) resolved.set(trade.id, trade);
+			if (ids.every((id) => resolved.has(id)) || Date.now() >= deadline) return ids.map((id) => resolved.get(id)).filter((trade) => trade !== void 0);
+			await sleep(RESOLVE_TRADES_POLL_INTERVAL_MS);
+		}
+	}
+	async resolveTransactionsHashes(response) {
+		if (response.transactionsHashes && response.transactionsHashes.length > 0) return response;
+		const tradeIDs = response.tradeIDs ?? [];
+		if (tradeIDs.length === 0) return response;
+		const transactionsHashes = (await this.waitForResolvedTrades(tradeIDs)).filter((trade) => trade.status.toUpperCase() !== FAILED_TRADE_STATUS).map((trade) => trade.transaction_hash).filter((hash) => Boolean(hash));
+		if (transactionsHashes.length === 0) return response;
+		return {
+			...response,
+			transactionsHashes
+		};
 	}
 	async cancelOrder(payload) {
 		this.canL2Auth();
@@ -828,6 +902,7 @@ var ClobClient = class {
 			if (!result?.condition_id) throw new Error(`failed to resolve condition id for token ${tokenID}`);
 			this.tokenConditionMap[tokenID] = result.condition_id;
 		}
+		if (tokenID in this.feeInfos) return;
 		await this.getClobMarketInfo(this.tokenConditionMap[tokenID]);
 	}
 	async ensureBuilderFeeRateCached(builderCode) {
@@ -853,16 +928,18 @@ var ClobClient = class {
 	}
 	async resolveVersion(forceUpdate = false) {
 		if (!forceUpdate && this.cachedVersion !== void 0) return this.cachedVersion;
-		const apiVersion = await this.getVersion();
-		this.cachedVersion = apiVersion;
-		return apiVersion;
-	}
-	async _retryOnVersionUpdate(retryFunc) {
-		const version = await this.resolveVersion();
-		for (let attempt = 0; attempt < 2; attempt++) {
-			await retryFunc();
-			if (version === await this.resolveVersion()) break;
+		if (!forceUpdate && this.versionRequest) return this.versionRequest;
+		return this.startVersionRequest();
+	}
+	async _retryOnVersionUpdate(attempt) {
+		try {
+			const response = await attempt();
+			if (!this._isOrderVersionMismatch(response)) return response;
+		} catch (err) {
+			const data = err instanceof ApiError ? err.data : void 0;
+			if (!this._isOrderVersionMismatch(data)) throw err;
 		}
+		return attempt();
 	}
 	_isOrderVersionMismatch(resp) {
 		const error = resp?.error;