@polymarket/clob-client-v2 1.0.4 → 1.0.6

package/dist/client.cjs

@@ -0,0 +1,886 @@
+const require_constants = require('./constants.cjs');
+const require_endpoints = require('./endpoints.cjs');
+const require_errors = require('./errors.cjs');
+const require_index = require('./fees/index.cjs');
+const require_index$1 = require('./headers/index.cjs');
+const require_index$2 = require('./http-helpers/index.cjs');
+const require_signatureTypeV2 = require('./order-utils/model/signatureTypeV2.cjs');
+const require_side = require('./order-utils/model/side.cjs');
+const require_clob = require('./types/clob.cjs');
+const require_ordersV1 = require('./types/ordersV1.cjs');
+const require_ordersV2 = require('./types/ordersV2.cjs');
+const require_unifiedOrder = require('./types/unifiedOrder.cjs');
+const require_utilities = require('./utilities.cjs');
+const require_calculateBuyMarketPrice = require('./order-builder/helpers/calculateBuyMarketPrice.cjs');
+const require_calculateSellMarketPrice = require('./order-builder/helpers/calculateSellMarketPrice.cjs');
+const require_roundingConfig = require('./order-builder/helpers/roundingConfig.cjs');
+const require_orderBuilder = require('./order-builder/orderBuilder.cjs');
+
+//#region src/client.ts
+var ClobClient = class {
+	host;
+	chainId;
+	signer;
+	creds;
+	orderBuilder;
+	tickSizes;
+	negRisk;
+	feeInfos;
+	feeRates;
+	builderFeeRates;
+	tokenConditionMap;
+	useServerTime;
+	builderConfig;
+	signatureType;
+	funderAddress;
+	cachedVersion;
+	retryOnError;
+	throwOnError;
+	feeSlippage;
+	constructor({ host, chain, signer, creds, signatureType, funderAddress, useServerTime, builderConfig, getSigner, retryOnError, throwOnError, feeSlippage }) {
+		this.host = host.endsWith("/") ? host.slice(0, -1) : host;
+		this.chainId = chain;
+		if (signer !== void 0) this.signer = signer;
+		if (creds !== void 0) this.creds = creds;
+		this.orderBuilder = new require_orderBuilder.OrderBuilder(signer, chain, signatureType, funderAddress, getSigner);
+		this.signatureType = signatureType ?? require_signatureTypeV2.SignatureTypeV2.EOA;
+		this.funderAddress = funderAddress;
+		this.tickSizes = {};
+		this.negRisk = {};
+		this.feeRates = {};
+		this.feeInfos = {};
+		this.builderFeeRates = {};
+		this.tokenConditionMap = {};
+		this.retryOnError = retryOnError;
+		this.throwOnError = throwOnError;
+		this.feeSlippage = feeSlippage ?? 0;
+		require_index.validateFeeSlippage(this.feeSlippage);
+		this.useServerTime = useServerTime;
+		if (builderConfig !== void 0) this.builderConfig = builderConfig;
+	}
+	async getOk() {
+		return this.get(`${this.host}${require_endpoints.OK}`);
+	}
+	async postHeartbeat(heartbeatId = "") {
+		this.canL2Auth();
+		const body = JSON.stringify({ heartbeat_id: heartbeatId });
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, {
+			method: require_index$2.POST,
+			requestPath: require_endpoints.HEARTBEAT,
+			body
+		}, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.post(`${this.host}${require_endpoints.HEARTBEAT}`, {
+			headers,
+			data: { heartbeat_id: heartbeatId }
+		});
+	}
+	async getVersion() {
+		return (await this.get(`${this.host}/version`))?.version ?? 2;
+	}
+	async getServerTime() {
+		return this.get(`${this.host}${require_endpoints.TIME}`);
+	}
+	async getSamplingSimplifiedMarkets(next_cursor = require_constants.INITIAL_CURSOR) {
+		return this.get(`${this.host}${require_endpoints.GET_SAMPLING_SIMPLIFIED_MARKETS}`, { params: { next_cursor } });
+	}
+	async getSamplingMarkets(next_cursor = require_constants.INITIAL_CURSOR) {
+		return this.get(`${this.host}${require_endpoints.GET_SAMPLING_MARKETS}`, { params: { next_cursor } });
+	}
+	async getSimplifiedMarkets(next_cursor = require_constants.INITIAL_CURSOR) {
+		return this.get(`${this.host}${require_endpoints.GET_SIMPLIFIED_MARKETS}`, { params: { next_cursor } });
+	}
+	async getMarkets(next_cursor = require_constants.INITIAL_CURSOR) {
+		return this.get(`${this.host}${require_endpoints.GET_MARKETS}`, { params: { next_cursor } });
+	}
+	async getMarket(conditionID) {
+		return this.get(`${this.host}${require_endpoints.GET_MARKET}${conditionID}`);
+	}
+	async getClobMarketInfo(conditionID) {
+		const result = await this.get(`${this.host}${require_endpoints.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) {
+			if (!token) continue;
+			const tokenId = token.t;
+			this.tokenConditionMap[tokenId] = conditionID;
+			this.tickSizes[tokenId] = result.mts.toString();
+			this.negRisk[tokenId] = result.nr ?? false;
+			this.feeInfos[tokenId] = {
+				rate: result.fd?.r ?? 0,
+				exponent: result.fd?.e ?? 0
+			};
+		}
+		return result;
+	}
+	async getOrderBook(tokenID) {
+		return this.get(`${this.host}${require_endpoints.GET_ORDER_BOOK}`, { params: { token_id: tokenID } });
+	}
+	async getOrderBooks(params) {
+		return this.post(`${this.host}${require_endpoints.GET_ORDER_BOOKS}`, { data: params });
+	}
+	async getTickSize(tokenID) {
+		if (tokenID in this.tickSizes) return this.tickSizes[tokenID];
+		if (tokenID in this.tokenConditionMap) {
+			await this.getClobMarketInfo(this.tokenConditionMap[tokenID]);
+			return this.tickSizes[tokenID];
+		}
+		const result = await this.get(`${this.host}${require_endpoints.GET_TICK_SIZE}`, { params: { token_id: tokenID } });
+		this.tickSizes[tokenID] = result.minimum_tick_size.toString();
+		return this.tickSizes[tokenID];
+	}
+	async getNegRisk(tokenID) {
+		if (tokenID in this.negRisk) return this.negRisk[tokenID];
+		if (tokenID in this.tokenConditionMap) {
+			await this.getClobMarketInfo(this.tokenConditionMap[tokenID]);
+			return this.negRisk[tokenID];
+		}
+		const result = await this.get(`${this.host}${require_endpoints.GET_NEG_RISK}`, { params: { token_id: tokenID } });
+		this.negRisk[tokenID] = result.neg_risk;
+		return this.negRisk[tokenID];
+	}
+	async getFeeRateBps(tokenID) {
+		if (tokenID in this.feeRates) return this.feeRates[tokenID];
+		const result = await this.get(`${this.host}${require_endpoints.GET_FEE_RATE}`, { params: { token_id: tokenID } });
+		this.feeRates[tokenID] = result.base_fee;
+		return this.feeRates[tokenID];
+	}
+	async getFeeExponent(tokenID) {
+		if (tokenID in this.feeInfos) return this.feeInfos[tokenID].exponent;
+		await this._ensureMarketInfoCached(tokenID);
+		return this.feeInfos[tokenID].exponent;
+	}
+	/**
+	* Calculates the hash for the given orderbook
+	* @param orderbook
+	* @returns
+	*/
+	async getOrderBookHash(orderbook) {
+		return require_utilities.generateOrderBookSummaryHash(orderbook);
+	}
+	async getMidpoint(tokenID) {
+		return this.get(`${this.host}${require_endpoints.GET_MIDPOINT}`, { params: { token_id: tokenID } });
+	}
+	async getMidpoints(params) {
+		return this.post(`${this.host}${require_endpoints.GET_MIDPOINTS}`, { data: params });
+	}
+	async getPrice(tokenID, side) {
+		return this.get(`${this.host}${require_endpoints.GET_PRICE}`, { params: {
+			token_id: tokenID,
+			side
+		} });
+	}
+	async getPrices(params) {
+		return this.post(`${this.host}${require_endpoints.GET_PRICES}`, { data: params });
+	}
+	async getSpread(tokenID) {
+		return this.get(`${this.host}${require_endpoints.GET_SPREAD}`, { params: { token_id: tokenID } });
+	}
+	async getSpreads(params) {
+		return this.post(`${this.host}${require_endpoints.GET_SPREADS}`, { data: params });
+	}
+	async getLastTradePrice(tokenID) {
+		return this.get(`${this.host}${require_endpoints.GET_LAST_TRADE_PRICE}`, { params: { token_id: tokenID } });
+	}
+	async getLastTradesPrices(params) {
+		return this.post(`${this.host}${require_endpoints.GET_LAST_TRADES_PRICES}`, { data: params });
+	}
+	async getPricesHistory(params) {
+		if (!params.interval && (params.startTs === void 0 || params.endTs === void 0)) throw new Error("getPricesHistory requires either interval or both startTs and endTs");
+		return this.get(`${this.host}${require_endpoints.GET_PRICES_HISTORY}`, { params });
+	}
+	/**
+	* Creates a new API key for a user
+	* @param nonce
+	* @returns ApiKeyCreds
+	*/
+	async createApiKey(nonce) {
+		this.canL1Auth();
+		const endpoint = `${this.host}${require_endpoints.CREATE_API_KEY}`;
+		const headers = await require_index$1.createL1Headers(this.signer, this.chainId, nonce, this.useServerTime ? await this.getServerTime() : void 0);
+		return await this.post(endpoint, { headers }).then((apiKeyRaw) => {
+			return {
+				key: apiKeyRaw.apiKey,
+				secret: apiKeyRaw.secret,
+				passphrase: apiKeyRaw.passphrase
+			};
+		});
+	}
+	/**
+	* Derives an existing API key for a user
+	* @param nonce
+	* @returns ApiKeyCreds
+	*/
+	async deriveApiKey(nonce) {
+		this.canL1Auth();
+		const endpoint = `${this.host}${require_endpoints.DERIVE_API_KEY}`;
+		const headers = await require_index$1.createL1Headers(this.signer, this.chainId, nonce, this.useServerTime ? await this.getServerTime() : void 0);
+		return await this.get(endpoint, { headers }).then((apiKeyRaw) => {
+			return {
+				key: apiKeyRaw.apiKey,
+				secret: apiKeyRaw.secret,
+				passphrase: apiKeyRaw.passphrase
+			};
+		});
+	}
+	async createOrDeriveApiKey(nonce) {
+		return this.createApiKey(nonce).then((response) => {
+			if (!response.key) return this.deriveApiKey(nonce);
+			return response;
+		});
+	}
+	async getApiKeys() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_API_KEYS;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.get(`${this.host}${endpoint}`, { headers });
+	}
+	async getClosedOnlyMode() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.CLOSED_ONLY;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.get(`${this.host}${endpoint}`, { headers });
+	}
+	async deleteApiKey() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.DELETE_API_KEY;
+		const headerArgs = {
+			method: require_index$2.DELETE,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.del(`${this.host}${endpoint}`, { headers });
+	}
+	async createReadonlyApiKey() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.CREATE_READONLY_API_KEY;
+		const headerArgs = {
+			method: require_index$2.POST,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.post(`${this.host}${endpoint}`, { headers });
+	}
+	async getReadonlyApiKeys() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_READONLY_API_KEYS;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.get(`${this.host}${endpoint}`, { headers });
+	}
+	async deleteReadonlyApiKey(key) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.DELETE_READONLY_API_KEY;
+		const payload = { key };
+		const headerArgs = {
+			method: require_index$2.DELETE,
+			requestPath: endpoint,
+			body: JSON.stringify(payload)
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.del(`${this.host}${endpoint}`, {
+			headers,
+			data: payload
+		});
+	}
+	async getOrder(orderID) {
+		this.canL2Auth();
+		const endpoint = `${require_endpoints.GET_ORDER}${orderID}`;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.get(`${this.host}${endpoint}`, { headers });
+	}
+	async getTrades(params, only_first_page = false, next_cursor) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_TRADES;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		let results = [];
+		next_cursor = next_cursor || require_constants.INITIAL_CURSOR;
+		while (next_cursor !== require_constants.END_CURSOR && (next_cursor === require_constants.INITIAL_CURSOR || !only_first_page)) {
+			const _params = {
+				...params,
+				next_cursor
+			};
+			const response = await this.get(`${this.host}${endpoint}`, {
+				headers,
+				params: _params
+			});
+			next_cursor = response.next_cursor;
+			results = [...results, ...response.data];
+		}
+		return results;
+	}
+	async getTradesPaginated(params, next_cursor) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_TRADES;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		next_cursor = next_cursor || require_constants.INITIAL_CURSOR;
+		const _params = {
+			...params,
+			next_cursor
+		};
+		const { data, ...rest } = await this.get(`${this.host}${endpoint}`, {
+			headers,
+			params: _params
+		});
+		return {
+			trades: Array.isArray(data) ? [...data] : [],
+			...rest
+		};
+	}
+	async getBuilderTrades(params, next_cursor) {
+		if (!params.builder_code || params.builder_code === require_constants.bytes32Zero) throw new Error("builderCode is required and cannot be zero");
+		const _params = {
+			...params,
+			next_cursor: next_cursor || require_constants.INITIAL_CURSOR
+		};
+		const { data, ...rest } = await this.get(`${this.host}${require_endpoints.GET_BUILDER_TRADES}`, { params: _params });
+		return {
+			trades: Array.isArray(data) ? [...data] : [],
+			...rest
+		};
+	}
+	async getNotifications() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_NOTIFICATIONS;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.get(`${this.host}${endpoint}`, {
+			headers,
+			params: { signature_type: this.orderBuilder.signatureType }
+		});
+	}
+	async dropNotifications(params) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.DROP_NOTIFICATIONS;
+		const l2HeaderArgs = {
+			method: require_index$2.DELETE,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, l2HeaderArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.del(`${this.host}${endpoint}`, {
+			headers,
+			params: require_index$2.parseDropNotificationParams(params)
+		});
+	}
+	async getBalanceAllowance(params) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_BALANCE_ALLOWANCE;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		const _params = {
+			...params,
+			signature_type: this.orderBuilder.signatureType
+		};
+		return this.get(`${this.host}${endpoint}`, {
+			headers,
+			params: _params
+		});
+	}
+	async updateBalanceAllowance(params) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.UPDATE_BALANCE_ALLOWANCE;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		const _params = {
+			...params,
+			signature_type: this.orderBuilder.signatureType
+		};
+		return this.get(`${this.host}${endpoint}`, {
+			headers,
+			params: _params
+		});
+	}
+	async createOrder(userOrder, options) {
+		this.canL1Auth();
+		const orderToSign = { ...userOrder };
+		if (this.builderConfig?.builderCode && !orderToSign.builderCode) orderToSign.builderCode = this.builderConfig.builderCode;
+		const { tokenID } = orderToSign;
+		const tickSize = await this._resolveTickSize(tokenID, options?.tickSize);
+		if (!require_utilities.priceValid(orderToSign.price, tickSize)) throw new Error(`invalid price (${orderToSign.price}), min: ${parseFloat(tickSize)} - max: ${1 - parseFloat(tickSize)}`);
+		orderToSign.price = require_utilities.roundNormal(orderToSign.price, require_roundingConfig.ROUNDING_CONFIG[tickSize].price);
+		const version = await this.resolveVersion();
+		if (version === 2 && orderToSign.side === require_side.Side.BUY && "userUSDCBalance" in orderToSign && orderToSign.userUSDCBalance !== void 0) orderToSign.size = await this.adjustBuyAmountForBalance(tokenID, orderToSign.size * orderToSign.price, orderToSign.price, orderToSign.userUSDCBalance, orderToSign.builderCode) / orderToSign.price;
+		const negRisk = options?.negRisk ?? await this.getNegRisk(tokenID);
+		if (version === 1) {
+			const userFeeRateBps = "feeRateBps" in orderToSign ? orderToSign.feeRateBps : void 0;
+			orderToSign.feeRateBps = await this._resolveFeeRateBps(tokenID, userFeeRateBps);
+		}
+		return this.orderBuilder.buildOrder(orderToSign, {
+			tickSize,
+			negRisk
+		}, version);
+	}
+	async createMarketOrder(userMarketOrder, options) {
+		this.canL1Auth();
+		const { tokenID } = userMarketOrder;
+		await this._ensureMarketInfoCached(tokenID);
+		const tickSize = await this._resolveTickSize(tokenID, options?.tickSize);
+		if (!userMarketOrder.price) userMarketOrder.price = await this.calculateMarketPrice(tokenID, userMarketOrder.side, userMarketOrder.amount, userMarketOrder.orderType);
+		if (!require_utilities.priceValid(userMarketOrder.price, tickSize)) throw new Error(`invalid price (${userMarketOrder.price}), min: ${parseFloat(tickSize)} - max: ${1 - parseFloat(tickSize)}`);
+		const orderToSign = { ...userMarketOrder };
+		if (this.builderConfig?.builderCode && !orderToSign.builderCode) orderToSign.builderCode = this.builderConfig.builderCode;
+		await this.ensureBuilderFeeRateCached(orderToSign.builderCode);
+		if (orderToSign.side === require_side.Side.BUY && "userUSDCBalance" in orderToSign && orderToSign.userUSDCBalance !== void 0) {
+			const price = orderToSign.price;
+			orderToSign.amount = await this.adjustBuyAmountForBalance(tokenID, orderToSign.amount, price, orderToSign.userUSDCBalance, orderToSign.builderCode);
+		}
+		const negRisk = options?.negRisk ?? await this.getNegRisk(tokenID);
+		const version = await this.resolveVersion();
+		if (version === 1) {
+			const userFeeRateBps = "feeRateBps" in orderToSign ? orderToSign.feeRateBps : void 0;
+			orderToSign.feeRateBps = await this._resolveFeeRateBps(tokenID, userFeeRateBps);
+		}
+		return this.orderBuilder.buildMarketOrder(orderToSign, {
+			tickSize,
+			negRisk
+		}, version);
+	}
+	async createAndPostOrder(userOrder, options, orderType = require_clob.OrderType.GTC, postOnly = false, deferExec = false) {
+		let postOrderResponse;
+		await this._retryOnVersionUpdate(async () => {
+			const order = await this.createOrder(userOrder, options);
+			postOrderResponse = await this.postOrder(order, orderType, postOnly, deferExec);
+		});
+		return postOrderResponse;
+	}
+	async createAndPostMarketOrder(userMarketOrder, options, orderType = require_clob.OrderType.FOK, deferExec = false) {
+		let postOrderMarketResponse;
+		await this._retryOnVersionUpdate(async () => {
+			const order = await this.createMarketOrder(userMarketOrder, options);
+			postOrderMarketResponse = await this.postOrder(order, orderType, false, deferExec);
+		});
+		return postOrderMarketResponse;
+	}
+	async getOpenOrders(params, only_first_page = false, next_cursor) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_OPEN_ORDERS;
+		const l2HeaderArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, l2HeaderArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		let results = [];
+		next_cursor = next_cursor || require_constants.INITIAL_CURSOR;
+		while (next_cursor !== require_constants.END_CURSOR && (next_cursor === require_constants.INITIAL_CURSOR || !only_first_page)) {
+			const _params = {
+				...params,
+				next_cursor
+			};
+			const response = await this.get(`${this.host}${endpoint}`, {
+				headers,
+				params: _params
+			});
+			next_cursor = response.next_cursor;
+			results = [...results, ...response.data];
+		}
+		return results;
+	}
+	async getPreMigrationOrders(only_first_page = false, next_cursor) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_PRE_MIGRATION_ORDERS;
+		const l2HeaderArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, l2HeaderArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		let results = [];
+		next_cursor = next_cursor || require_constants.INITIAL_CURSOR;
+		while (next_cursor !== require_constants.END_CURSOR && (next_cursor === require_constants.INITIAL_CURSOR || !only_first_page)) {
+			const _params = { next_cursor };
+			const response = await this.get(`${this.host}${endpoint}`, {
+				headers,
+				params: _params
+			});
+			next_cursor = response.next_cursor;
+			results = [...results, ...response.data];
+		}
+		return results;
+	}
+	async postOrder(order, orderType = require_clob.OrderType.GTC, postOnly = false, deferExec = false) {
+		this.canL2Auth();
+		if (postOnly && (orderType === require_clob.OrderType.FOK || orderType === require_clob.OrderType.FAK)) throw new Error("postOnly is not supported for FOK/FAK orders");
+		const endpoint = require_endpoints.POST_ORDER;
+		const orderPayload = require_unifiedOrder.isV2Order(order) ? require_ordersV2.orderToJsonV2(order, this.creds?.key || "", orderType, postOnly, deferExec) : require_ordersV1.orderToJsonV1(order, this.creds?.key || "", orderType, postOnly, deferExec);
+		const l2HeaderArgs = {
+			method: require_index$2.POST,
+			requestPath: endpoint,
+			body: JSON.stringify(orderPayload)
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, l2HeaderArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		const res = await this.post(`${this.host}${endpoint}`, {
+			headers,
+			data: orderPayload
+		}, true);
+		if (this._isOrderVersionMismatch(res)) await this.resolveVersion(true);
+		return this.throwIfError(res);
+	}
+	async postOrders(args, postOnly = false, deferExec = false) {
+		this.canL2Auth();
+		if (postOnly && args.some(({ orderType }) => orderType === require_clob.OrderType.FOK || orderType === require_clob.OrderType.FAK)) throw new Error("postOnly is not supported for FOK/FAK orders");
+		const endpoint = require_endpoints.POST_ORDERS;
+		const ordersPayload = [];
+		for (const arg of args) {
+			const { order, orderType } = arg;
+			const orderPayload = require_unifiedOrder.isV2Order(order) ? require_ordersV2.orderToJsonV2(order, this.creds?.key || "", orderType, postOnly, deferExec) : require_ordersV1.orderToJsonV1(order, this.creds?.key || "", orderType, postOnly, deferExec);
+			ordersPayload.push(orderPayload);
+		}
+		const l2HeaderArgs = {
+			method: require_index$2.POST,
+			requestPath: endpoint,
+			body: JSON.stringify(ordersPayload)
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, l2HeaderArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		const res = await this.post(`${this.host}${endpoint}`, {
+			headers,
+			data: ordersPayload
+		}, true);
+		if (this._isOrderVersionMismatch(res)) await this.resolveVersion(true);
+		return this.throwIfError(res);
+	}
+	async cancelOrder(payload) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.CANCEL_ORDER;
+		const l2HeaderArgs = {
+			method: require_index$2.DELETE,
+			requestPath: endpoint,
+			body: JSON.stringify(payload)
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, l2HeaderArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.del(`${this.host}${endpoint}`, {
+			headers,
+			data: payload
+		});
+	}
+	async cancelOrders(ordersHashes) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.CANCEL_ORDERS;
+		const l2HeaderArgs = {
+			method: require_index$2.DELETE,
+			requestPath: endpoint,
+			body: JSON.stringify(ordersHashes)
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, l2HeaderArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.del(`${this.host}${endpoint}`, {
+			headers,
+			data: ordersHashes
+		});
+	}
+	async cancelAll() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.CANCEL_ALL;
+		const l2HeaderArgs = {
+			method: require_index$2.DELETE,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, l2HeaderArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.del(`${this.host}${endpoint}`, { headers });
+	}
+	async cancelMarketOrders(payload) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.CANCEL_MARKET_ORDERS;
+		const l2HeaderArgs = {
+			method: require_index$2.DELETE,
+			requestPath: endpoint,
+			body: JSON.stringify(payload)
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, l2HeaderArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.del(`${this.host}${endpoint}`, {
+			headers,
+			data: payload
+		});
+	}
+	async isOrderScoring(params) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.IS_ORDER_SCORING;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.get(`${this.host}${endpoint}`, {
+			headers,
+			params
+		});
+	}
+	async areOrdersScoring(params) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.ARE_ORDERS_SCORING;
+		const payload = JSON.stringify(params?.orderIds);
+		const headerArgs = {
+			method: require_index$2.POST,
+			requestPath: endpoint,
+			body: payload
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.post(`${this.host}${endpoint}`, {
+			headers,
+			data: payload
+		});
+	}
+	async getEarningsForUserForDay(date) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_EARNINGS_FOR_USER_FOR_DAY;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		let results = [];
+		let next_cursor = require_constants.INITIAL_CURSOR;
+		while (next_cursor !== require_constants.END_CURSOR) {
+			const params = {
+				date,
+				signature_type: this.orderBuilder.signatureType,
+				next_cursor
+			};
+			const response = await this.get(`${this.host}${endpoint}`, {
+				headers,
+				params
+			});
+			next_cursor = response.next_cursor;
+			results = [...results, ...response.data];
+		}
+		return results;
+	}
+	async getTotalEarningsForUserForDay(date) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_TOTAL_EARNINGS_FOR_USER_FOR_DAY;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		const params = {
+			date,
+			signature_type: this.orderBuilder.signatureType
+		};
+		return await this.get(`${this.host}${endpoint}`, {
+			headers,
+			params
+		});
+	}
+	async getUserEarningsAndMarketsConfig(date, order_by = "", position = "", no_competition = false) {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_REWARDS_EARNINGS_PERCENTAGES;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		let results = [];
+		let next_cursor = require_constants.INITIAL_CURSOR;
+		while (next_cursor !== require_constants.END_CURSOR) {
+			const params = {
+				date,
+				signature_type: this.orderBuilder.signatureType,
+				next_cursor,
+				order_by,
+				position,
+				no_competition
+			};
+			const response = await this.get(`${this.host}${endpoint}`, {
+				headers,
+				params
+			});
+			next_cursor = response.next_cursor;
+			results = [...results, ...response.data];
+		}
+		return results;
+	}
+	async getRewardPercentages() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_LIQUIDITY_REWARD_PERCENTAGES;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		const _params = { signature_type: this.orderBuilder.signatureType };
+		return this.get(`${this.host}${endpoint}`, {
+			headers,
+			params: _params
+		});
+	}
+	async getCurrentRewards() {
+		let results = [];
+		let next_cursor = require_constants.INITIAL_CURSOR;
+		while (next_cursor !== require_constants.END_CURSOR) {
+			const response = await this.get(`${this.host}${require_endpoints.GET_REWARDS_MARKETS_CURRENT}`, { params: { next_cursor } });
+			next_cursor = response.next_cursor;
+			results = [...results, ...response.data];
+		}
+		return results;
+	}
+	async getRawRewardsForMarket(conditionId) {
+		let results = [];
+		let next_cursor = require_constants.INITIAL_CURSOR;
+		while (next_cursor !== require_constants.END_CURSOR) {
+			const response = await this.get(`${this.host}${require_endpoints.GET_REWARDS_MARKETS}${conditionId}`, { params: { next_cursor } });
+			next_cursor = response.next_cursor;
+			results = [...results, ...response.data];
+		}
+		return results;
+	}
+	async calculateMarketPrice(tokenID, side, amount, orderType = require_clob.OrderType.FOK) {
+		const book = await this.getOrderBook(tokenID);
+		if (!book) throw new Error("no orderbook");
+		if (side === require_side.Side.BUY) {
+			if (!book.asks) throw new Error("no match");
+			return require_calculateBuyMarketPrice.calculateBuyMarketPrice(book.asks, amount, orderType);
+		} else {
+			if (!book.bids) throw new Error("no match");
+			return require_calculateSellMarketPrice.calculateSellMarketPrice(book.bids, amount, orderType);
+		}
+	}
+	async createBuilderApiKey() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.CREATE_BUILDER_API_KEY;
+		const headerArgs = {
+			method: require_index$2.POST,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.post(`${this.host}${endpoint}`, { headers });
+	}
+	async getBuilderApiKeys() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.GET_BUILDER_API_KEYS;
+		const headerArgs = {
+			method: require_index$2.GET,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.get(`${this.host}${endpoint}`, { headers });
+	}
+	async revokeBuilderApiKey() {
+		this.canL2Auth();
+		const endpoint = require_endpoints.REVOKE_BUILDER_API_KEY;
+		const headerArgs = {
+			method: require_index$2.DELETE,
+			requestPath: endpoint
+		};
+		const headers = await require_index$1.createL2Headers(this.signer, this.creds, headerArgs, this.useServerTime ? await this.getServerTime() : void 0);
+		return this.del(`${this.host}${endpoint}`, { headers });
+	}
+	async getMarketTradesEvents(conditionID) {
+		return this.get(`${this.host}${require_endpoints.GET_MARKET_TRADES_EVENTS}${conditionID}`);
+	}
+	canL1Auth() {
+		if (this.signer === void 0) throw require_errors.L1_AUTH_UNAVAILABLE_ERROR;
+	}
+	canL2Auth() {
+		if (this.signer === void 0) throw require_errors.L1_AUTH_UNAVAILABLE_ERROR;
+		if (this.creds === void 0) throw require_errors.L2_AUTH_NOT_AVAILABLE;
+	}
+	isBuilderOrder(builderCode) {
+		return builderCode !== void 0 && builderCode !== require_constants.bytes32Zero;
+	}
+	async getBuilderTakerFeeRate(builderCode) {
+		if (!this.isBuilderOrder(builderCode)) return 0;
+		await this.ensureBuilderFeeRateCached(builderCode);
+		return this.builderFeeRates[builderCode ?? ""]?.taker ?? 0;
+	}
+	async adjustBuyAmountForBalance(tokenID, amount, price, userUSDCBalance, builderCode) {
+		await this._ensureMarketInfoCached(tokenID);
+		const builderTakerFeeRate = await this.getBuilderTakerFeeRate(builderCode);
+		return require_index.adjustBuyAmountForFees(amount, price, userUSDCBalance, this.feeInfos[tokenID].rate, this.feeInfos[tokenID].exponent, builderTakerFeeRate, this.feeSlippage);
+	}
+	async _ensureMarketInfoCached(tokenID) {
+		if (tokenID in this.feeInfos) return;
+		if (!(tokenID in this.tokenConditionMap)) {
+			const result = await this.get(`${this.host}${require_endpoints.GET_MARKET_BY_TOKEN}${tokenID}`);
+			if (!result?.condition_id) throw new Error(`failed to resolve condition id for token ${tokenID}`);
+			this.tokenConditionMap[tokenID] = result.condition_id;
+		}
+		await this.getClobMarketInfo(this.tokenConditionMap[tokenID]);
+	}
+	async ensureBuilderFeeRateCached(builderCode) {
+		if (!builderCode || builderCode === require_constants.bytes32Zero) return;
+		if (builderCode in this.builderFeeRates) return;
+		const result = await this.get(`${this.host}${require_endpoints.GET_BUILDER_FEES}${builderCode}`);
+		this.builderFeeRates[builderCode] = {
+			maker: result.builder_maker_fee_rate_bps / require_constants.BUILDER_FEES_BPS,
+			taker: result.builder_taker_fee_rate_bps / require_constants.BUILDER_FEES_BPS
+		};
+	}
+	async _resolveTickSize(tokenID, tickSize) {
+		const minTickSize = await this.getTickSize(tokenID);
+		if (tickSize) {
+			if (require_utilities.isTickSizeSmaller(tickSize, minTickSize)) throw new Error(`invalid tick size (${tickSize}), minimum for the market is ${minTickSize}`);
+		} else tickSize = minTickSize;
+		return tickSize;
+	}
+	async _resolveFeeRateBps(tokenID, userFeeRateBps) {
+		const marketFeeRateBps = await this.getFeeRateBps(tokenID);
+		if (marketFeeRateBps > 0 && userFeeRateBps !== void 0 && userFeeRateBps !== marketFeeRateBps) throw new Error(`invalid user provided fee rate: ${userFeeRateBps}, fee rate for the market must be ${marketFeeRateBps}`);
+		return marketFeeRateBps;
+	}
+	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;
+		}
+	}
+	_isOrderVersionMismatch(resp) {
+		const error = resp?.error;
+		if (!error) return false;
+		return (typeof error === "string" ? error : JSON.stringify(error)).includes(require_constants.ORDER_VERSION_MISMATCH_ERROR);
+	}
+	throwIfError(result) {
+		if (this.throwOnError && result && typeof result === "object" && "error" in result) throw new require_errors.ApiError(typeof result.error === "string" ? result.error : JSON.stringify(result.error), result.status, result);
+		return result;
+	}
+	async get(endpoint, options, skipThrow = false) {
+		const result = await require_index$2.get(endpoint, options);
+		return skipThrow ? result : this.throwIfError(result);
+	}
+	async post(endpoint, options, skipThrow = false) {
+		const result = await require_index$2.post(endpoint, options, this.retryOnError);
+		return skipThrow ? result : this.throwIfError(result);
+	}
+	async del(endpoint, options, skipThrow = false) {
+		const result = await require_index$2.del(endpoint, options);
+		return skipThrow ? result : this.throwIfError(result);
+	}
+};
+
+//#endregion
+exports.ClobClient = ClobClient;
+//# sourceMappingURL=client.cjs.map