@jsnw/kalshi-client 0.0.1 → 0.2.0

package/dist/index.cjs

@@ -4,6 +4,7 @@ let zod = require("zod");
 let uuid = require("uuid");
 let ws = require("ws");
 let node_timers_promises = require("node:timers/promises");
+let _jsnw_api_client = require("@jsnw/api-client");
 //#region src/request-signer.ts
 var RequestSigner = class {
 	privkey;
@@ -78,8 +79,39 @@ const primitives$fixedPointSchema = zod.z.string().regex(/^\d{1,14}\.\d{2,8}$/);
 const primitives$orderSideSchema = zod.z.enum(["yes", "no"]);
 const primitives$bookSideSchema = zod.z.enum(["bid", "ask"]);
 const primitives$orderActionSchema = zod.z.enum(["buy", "sell"]);
+const primitives$rateLimitBucketMetaSchema = zod.z.object({
+	refill_rate: zod.z.number(),
+	bucket_capacity: zod.z.number()
+});
+//#endregion
+//#region src/schemas/http.ts
+const http$errorMessageSchema = zod.z.object({
+	code: zod.z.number(),
+	message: zod.z.string().optional(),
+	details: zod.z.any().optional(),
+	service: zod.z.any().optional()
+});
+//#endregion
+//#region src/schemas/account.ts
+const account$accountTierSchema = zod.z.enum([
+	"basic",
+	"advanced",
+	"expert",
+	"premier",
+	"paragon",
+	"prime",
+	"prestige"
+]);
+const account$subaccountSchema = zod.z.number().min(0).max(63).default(0);
+const account$accountGrantSchema = zod.z.object({
+	exchange_instance: zod.z.enum(["event_contract", "margined"]),
+	level: account$accountTierSchema,
+	source: zod.z.enum(["volume", "manual"]),
+	expires_ts: zod.z.number().nullable().default(null)
+});
 //#endregion
 //#region src/schemas/orders.ts
+const orders$clientOrderIdSchema = zod.z.string().nullable().optional();
 const orders$orderStatusSchema = zod.z.enum([
 	"resting",
 	"canceled",
@@ -87,17 +119,22 @@ const orders$orderStatusSchema = zod.z.enum([
 ]);
 const orders$orderTypeSchema = zod.z.enum(["limit", "market"]);
 const orders$selfTradePreventionTypeSchema = zod.z.enum(["taker_at_cross", "maker"]);
+const orders$timeInForceSchema = zod.z.enum([
+	"fill_or_kill",
+	"good_till_canceled",
+	"immediate_or_cancel"
+]);
 const orders$orderDetailedSchema = zod.z.object({
 	order_id: zod.z.uuid(),
 	user_id: zod.z.uuid(),
-	subaccount_number: zod.z.number().min(0).max(32).default(0),
-	order_group_id: zod.z.uuid().nullable().optional(),
+	client_order_id: orders$clientOrderIdSchema,
+	order_group_id: zod.z.string().nullable().optional(),
+	subaccount_number: account$subaccountSchema,
 	exchange_index: zod.z.number().min(0).default(0),
-	client_order_id: zod.z.string(),
 	ticker: zod.z.string(),
+	type: orders$orderTypeSchema,
 	outcome_side: primitives$orderSideSchema,
 	book_side: primitives$bookSideSchema,
-	type: orders$orderTypeSchema,
 	status: orders$orderStatusSchema,
 	yes_price_dollars: primitives$fixedPointSchema,
 	no_price_dollars: primitives$fixedPointSchema,
@@ -108,11 +145,11 @@ const orders$orderDetailedSchema = zod.z.object({
 	maker_fill_cost_dollars: primitives$fixedPointSchema,
 	taker_fees_dollars: primitives$fixedPointSchema,
 	maker_fees_dollars: primitives$fixedPointSchema,
-	self_trade_prevention_type: orders$selfTradePreventionTypeSchema.nullable().optional(),
+	self_trade_prevention_type: orders$selfTradePreventionTypeSchema,
 	cancel_order_on_pause: zod.z.boolean(),
 	created_time: zod.z.iso.datetime(),
-	expiration_time: zod.z.iso.datetime().nullable().optional(),
-	last_update_time: zod.z.iso.datetime().nullable().optional()
+	last_update_time: zod.z.iso.datetime().nullable().optional(),
+	expiration_time: zod.z.iso.datetime().nullable().optional()
 });
 const orders$orderWsSchema = orders$orderDetailedSchema.omit({
 	exchange_index: true,
@@ -125,12 +162,32 @@ const orders$orderWsSchema = orders$orderDetailedSchema.omit({
 	last_updated_ts_ms: zod.z.number().positive().optional(),
 	expiration_ts_ms: zod.z.number().positive().optional()
 });
+const orders$createOrderDtoSchema = zod.z.object({
+	client_order_id: zod.z.string().optional(),
+	order_group_id: zod.z.string().optional(),
+	exchange_index: zod.z.number().min(0).default(0),
+	ticker: zod.z.string(),
+	side: primitives$bookSideSchema,
+	count: primitives$fixedPointSchema,
+	subaccount: account$subaccountSchema,
+	price: primitives$fixedPointSchema,
+	post_only: zod.z.boolean().default(false),
+	reduce_only: zod.z.boolean().default(false),
+	cancel_order_on_pause: zod.z.boolean(),
+	self_trade_prevention_type: orders$selfTradePreventionTypeSchema,
+	time_in_force: orders$timeInForceSchema,
+	expiration_time: zod.z.number().optional()
+});
 //#endregion
 //#region src/consts.ts
 const KALSHI_WS_URL = {
 	"development": "wss://external-api-ws.demo.kalshi.co",
 	"production": "wss://external-api-ws.kalshi.com"
 };
+const KALSHI_API_URL = {
+	"development": "https://external-api.demo.kalshi.co",
+	"production": "https://external-api.kalshi.com"
+};
 //#endregion
 //#region src/typed-emitter.ts
 var TypedEmitter = class {
@@ -502,6 +559,8 @@ var WsKalshiError = class extends Error {
 		this.code = code;
 	}
 };
+var WsClosedError = class extends Error {};
+var WsClosedByUserError = class extends Error {};
 //#endregion
 //#region src/ws/ws-client.ts
 var WsClient = class extends TypedEmitter {
@@ -546,9 +605,39 @@ var WsClient = class extends TypedEmitter {
 		this.ws.on("reconnecting", this.onReconnecting);
 		this.ws.on("close", this.onClose);
 	}
+	/**
+	* @return {Promise<void>}
+	*/
+	connect() {
+		return this.ws.open();
+	}
+	/**
+	* @return {Promise<void>}
+	*/
+	async subscribe(options) {
+		const { channel, timeoutMs, ...rest } = options;
+		const messageId = ++this.lastMessageId;
+		const payload = {
+			id: messageId,
+			cmd: "subscribe",
+			params: {
+				channels: [channel],
+				...rest
+			}
+		};
+		const promise = this.subscribeAwaiters.add(messageId, timeoutMs ?? 2e3);
+		await this.ws.send(JSON.stringify(payload));
+		return promise;
+	}
+	/**
+	* @return {Promise<void>}
+	*/
+	close() {
+		this.subscribeAwaiters.clear(new WsClosedByUserError());
+		return this.ws.close();
+	}
 	onReady = async (afterReconnect) => {
-		this.log("debug", "WebSocket connection ready", { afterReconnect });
-		this.emit("ready");
+		this.emit("ready", afterReconnect);
 	};
 	/**
 	* @param {WebSocket.RawData} data
@@ -582,21 +671,19 @@ var WsClient = class extends TypedEmitter {
 	* @param {number} attempt
 	*/
 	onReconnecting = (attempt) => {
-		this.log("debug", "reconnecting", { attempt });
 		this.emit("reconnect", attempt);
 	};
 	/**
 	* @param {Error} err
 	*/
 	onError = (err) => {
-		this.log("error", "WebSocket error", { err });
+		this.emit("ws_error", err);
 	};
 	/**
 	*/
 	onClose = () => {
-		this.log("debug", "WebSocket connection closed");
 		this.emit("close");
-		this.subscribeAwaiters.clear();
+		this.subscribeAwaiters.clear(new WsClosedError());
 	};
 	/**
 	* @param {WsAnyMessage} msg
@@ -650,21 +737,192 @@ const WS_KALSHI_SERVER_ERRORS = [
 	WS_KALSHI_ERRORS.COMMAND_TIMEOUT
 ];
 //#endregion
+//#region src/api/metadata.ts
+const METADATA = { NO_AUTH: Symbol("no-auth") };
+//#endregion
+//#region src/api/router/exchange.ts
+const exchangeRouter = (0, _jsnw_api_client.createRouter)({
+	getStatus: {
+		method: "get",
+		path: "/status",
+		responses: { 200: zod.z.object({
+			exchange_active: zod.z.boolean(),
+			trading_active: zod.z.boolean(),
+			exchange_estimated_resume_time: zod.z.iso.datetime().nullable().optional()
+		}) }
+	},
+	getUserDataTimestamp: {
+		method: "get",
+		path: "/user_data_timestamp",
+		responses: { 200: zod.z.object({ as_of_time: zod.z.iso.datetime() }) }
+	}
+}, {
+	path: "exchange",
+	metadata: { [METADATA.NO_AUTH]: true }
+});
+//#endregion
+//#region src/api/router/account.ts
+const accountRouter = (0, _jsnw_api_client.createRouter)({
+	getLimits: {
+		method: "get",
+		path: "/limits",
+		responses: { 200: zod.z.object({
+			usage_tier: account$accountTierSchema,
+			read: primitives$rateLimitBucketMetaSchema,
+			write: primitives$rateLimitBucketMetaSchema,
+			grants: zod.z.array(account$accountGrantSchema)
+		}) }
+	},
+	listNonDefaultEndpointCosts: {
+		method: "get",
+		path: "/endpoint_costs",
+		responses: { 200: zod.z.object({
+			default_cost: zod.z.number().min(0),
+			endpoint_costs: zod.z.array(zod.z.object({
+				method: zod.z.string(),
+				path: zod.z.string(),
+				cost: zod.z.number().min(0)
+			}))
+		}) },
+		metadata: { [METADATA.NO_AUTH]: true }
+	}
+}, { path: "/account" });
+//#endregion
+//#region src/api/router/orders.ts
+const ordersRouter = (0, _jsnw_api_client.createRouter)({
+	getOrder: {
+		method: "get",
+		path: "/orders/:order_id",
+		params: zod.z.object({ order_id: zod.z.uuid() }),
+		responses: { 200: zod.z.object({ order: orders$orderDetailedSchema }) }
+	},
+	createOrder: {
+		method: "post",
+		path: "/events/orders",
+		body: orders$createOrderDtoSchema,
+		responses: { 201: zod.z.object({
+			order_id: zod.z.uuid(),
+			client_order_id: orders$clientOrderIdSchema,
+			fill_count: primitives$fixedPointSchema,
+			remaining_count: primitives$fixedPointSchema,
+			average_fill_price: primitives$fixedPointSchema.nullable().optional(),
+			average_fee_paid: primitives$fixedPointSchema.nullable().optional(),
+			ts_ms: zod.z.number().min(0)
+		}) }
+	},
+	cancelOrderV1: {
+		method: "delete",
+		path: "/orders/:order_id",
+		params: zod.z.object({ order_id: zod.z.uuid() }),
+		query: zod.z.object({
+			subaccount: zod.z.number().min(0).max(63).default(0),
+			exchange_index: zod.z.number().min(0).default(0)
+		}).prefault({}),
+		responses: { 200: zod.z.object({
+			order: orders$orderDetailedSchema,
+			reduced_by_fp: primitives$fixedPointSchema
+		}) }
+	},
+	cancelOrderV2: {
+		method: "delete",
+		path: "/events/orders/:order_id",
+		params: zod.z.object({ order_id: zod.z.uuid() }),
+		query: zod.z.object({
+			subaccount: zod.z.number().min(0).max(63).default(0),
+			exchange_index: zod.z.number().min(0).default(0)
+		}).prefault({}),
+		responses: { 200: zod.z.object({
+			order_id: zod.z.uuid(),
+			client_order_id: orders$clientOrderIdSchema,
+			reduced_by: primitives$fixedPointSchema,
+			ts_ms: zod.z.number().min(0)
+		}) }
+	},
+	getOrderQueuePosition: {
+		method: "get",
+		path: "/orders/:order_id/queue_position",
+		params: zod.z.object({ order_id: zod.z.uuid() }),
+		responses: { 200: zod.z.object({ queue_position_fp: primitives$fixedPointSchema }) }
+	}
+}, { path: "/portfolio" });
+//#endregion
+//#region src/api/router/index.ts
+const apiRouter = (0, _jsnw_api_client.createRouter)({
+	exchange: exchangeRouter,
+	account: accountRouter,
+	orders: ordersRouter
+}, { path: "/trade-api/v2" });
+//#endregion
+//#region src/api/client.ts
+var ApiClient = class extends _jsnw_api_client.ApiClient {
+	/**
+	* @param {ApiClientConfig} config
+	*/
+	constructor(config) {
+		super(apiRouter, {
+			...config,
+			baseURL: KALSHI_API_URL[config.environment ?? "development"],
+			qsArrayFormat: "brackets",
+			contentType: "application/json"
+		});
+	}
+	/**
+	* @template {Route} TRoute
+	* @param {TRoute} route
+	* @param {ApiRequestParams<TRoute>} params
+	* @param {ApiCallOptions} options
+	* @return {Promise<ApiResponse<TRoute>>}
+	*/
+	/**
+	* @param {"force"} force
+	* @return {Promise<void>}
+	* @private
+	*/
+	/**
+	* @param {ApiRawRequest} req
+	* @return {ApiRawRequest}
+	* @protected
+	*/
+	onBeforeRequest(req) {
+		if (req.route.metadata?.[METADATA.NO_AUTH] && req.route.metadata[METADATA.NO_AUTH] === true) return req;
+		const ts = Date.now();
+		req.headers["kalshi-access-key"] = this.config.credentialsProvider.getAccessKey();
+		req.headers["kalshi-access-timestamp"] = ts.toString();
+		req.headers["kalshi-access-signature"] = this.config.credentialsProvider.getSignature({
+			httpMethod: req.route.method,
+			path: req.path,
+			timestamp: ts
+		});
+		return req;
+	}
+};
+//#endregion
+exports.ApiClient = ApiClient;
 exports.InMemoryCredentialsProvider = InMemoryCredentialsProvider;
 exports.RequestSigner = RequestSigner;
 exports.WS_KALSHI_ERRORS = WS_KALSHI_ERRORS;
 exports.WS_KALSHI_SERVER_ERRORS = WS_KALSHI_SERVER_ERRORS;
 exports.WsClient = WsClient;
+exports.WsClosedByUserError = WsClosedByUserError;
+exports.WsClosedError = WsClosedError;
 exports.WsKalshiError = WsKalshiError;
+exports.account$accountGrantSchema = account$accountGrantSchema;
+exports.account$accountTierSchema = account$accountTierSchema;
+exports.account$subaccountSchema = account$subaccountSchema;
+exports.http$errorMessageSchema = http$errorMessageSchema;
+exports.orders$clientOrderIdSchema = orders$clientOrderIdSchema;
+exports.orders$createOrderDtoSchema = orders$createOrderDtoSchema;
 exports.orders$orderDetailedSchema = orders$orderDetailedSchema;
 exports.orders$orderStatusSchema = orders$orderStatusSchema;
 exports.orders$orderTypeSchema = orders$orderTypeSchema;
 exports.orders$orderWsSchema = orders$orderWsSchema;
 exports.orders$selfTradePreventionTypeSchema = orders$selfTradePreventionTypeSchema;
+exports.orders$timeInForceSchema = orders$timeInForceSchema;
 exports.primitives$bookSideSchema = primitives$bookSideSchema;
 exports.primitives$fixedPointSchema = primitives$fixedPointSchema;
 exports.primitives$orderActionSchema = primitives$orderActionSchema;
 exports.primitives$orderSideSchema = primitives$orderSideSchema;
+exports.primitives$rateLimitBucketMetaSchema = primitives$rateLimitBucketMetaSchema;
 exports.wsAnyMessageSchema = wsAnyMessageSchema;
 exports.wsErrorMessageSchema = wsErrorMessageSchema;
 exports.wsOkMessageSchema = wsOkMessageSchema;