@medievalrain/binance-ts 0.1.0

package/dist/index.js

@@ -0,0 +1,1145 @@
+import z$1, { z } from "zod";
+import { Client, WebSocket } from "undici";
+import * as z4 from "zod/v4/core";
+import { createHmac } from "node:crypto";
+
+//#region src/rest/futures/schema.ts
+const FuturesTestConnectivitySchema = z.object({});
+const FuturesCheckServerTimeSchema = z.object({ serverTime: z.number() });
+const FuturesExchangeInfoRateLimitSchema = z.object({
+	interval: z.enum(["MINUTE", "SECOND"]),
+	intervalNum: z.number(),
+	limit: z.number(),
+	rateLimitType: z.enum(["REQUEST_WEIGHT", "ORDERS"])
+});
+const FuturesExchangeInfoAssetSchema = z.object({
+	asset: z.string(),
+	marginAvailable: z.boolean(),
+	autoAssetExchange: z.string().nullable()
+});
+const FuturesExchangeInfoFilterSchema = z.discriminatedUnion("filterType", [
+	z.object({
+		filterType: z.literal("PRICE_FILTER"),
+		maxPrice: z.coerce.number(),
+		minPrice: z.coerce.number(),
+		tickSize: z.coerce.number()
+	}),
+	z.object({
+		filterType: z.literal("LOT_SIZE"),
+		maxQty: z.coerce.number(),
+		minQty: z.coerce.number(),
+		stepSize: z.coerce.number()
+	}),
+	z.object({
+		filterType: z.literal("MARKET_LOT_SIZE"),
+		maxQty: z.coerce.number(),
+		minQty: z.coerce.number(),
+		stepSize: z.coerce.number()
+	}),
+	z.object({
+		filterType: z.literal("MAX_NUM_ORDERS"),
+		limit: z.number()
+	}),
+	z.object({
+		filterType: z.literal("MAX_NUM_ALGO_ORDERS"),
+		limit: z.number()
+	}),
+	z.object({
+		filterType: z.literal("MIN_NOTIONAL"),
+		notional: z.string()
+	}),
+	z.object({
+		filterType: z.literal("PERCENT_PRICE"),
+		multiplierUp: z.coerce.number(),
+		multiplierDown: z.coerce.number().optional(),
+		multiplierDecimal: z.coerce.number().optional()
+	}),
+	z.object({
+		filterType: z.literal("POSITION_RISK_CONTROL"),
+		positionControlSide: z.literal("NONE"),
+		multiplierDown: z.coerce.number().optional(),
+		multiplierDecimal: z.coerce.number().optional()
+	})
+]);
+const FuturesContractTypeSchema = z.enum([
+	"PERPETUAL",
+	"CURRENT_QUARTER",
+	"NEXT_QUARTER"
+]);
+const FuturesUnderlyingTypeSchema = z.enum([
+	"COIN",
+	"INDEX",
+	"PREMARKET"
+]);
+const FuturesOrderTypeSchema = z.enum([
+	"LIMIT",
+	"MARKET",
+	"STOP",
+	"TAKE_PROFIT",
+	"STOP_MARKET",
+	"TAKE_PROFIT_MARKET",
+	"TRAILING_STOP_MARKET"
+]);
+const FuturesExchangeInfoSymbolSchema = z.object({
+	symbol: z.string(),
+	pair: z.string(),
+	contractType: FuturesContractTypeSchema,
+	deliveryDate: z.number(),
+	onboardDate: z.number(),
+	status: z.enum([
+		"TRADING",
+		"SETTLING",
+		"PENDING_TRADING"
+	]),
+	maintMarginPercent: z.string(),
+	requiredMarginPercent: z.string(),
+	baseAsset: z.string(),
+	quoteAsset: z.string(),
+	marginAsset: z.string(),
+	pricePrecision: z.number(),
+	quantityPrecision: z.number(),
+	baseAssetPrecision: z.number(),
+	quotePrecision: z.number(),
+	underlyingType: FuturesUnderlyingTypeSchema,
+	underlyingSubType: z.array(z.string()),
+	permissionSets: z.array(z.enum(["COPY", "GRID"])),
+	settlePlan: z.number().optional(),
+	triggerProtect: z.string(),
+	filters: z.array(FuturesExchangeInfoFilterSchema),
+	OrderType: z.array(FuturesOrderTypeSchema).optional(),
+	timeInForce: z.array(z.string()),
+	liquidationFee: z.coerce.number(),
+	marketTakeBound: z.coerce.number()
+});
+const FuturesExchangeInfoSchema = z.object({
+	exchangeFilters: z.array(z.unknown()),
+	rateLimits: z.array(FuturesExchangeInfoRateLimitSchema),
+	serverTime: z.number(),
+	assets: z.array(FuturesExchangeInfoAssetSchema),
+	symbols: z.array(FuturesExchangeInfoSymbolSchema),
+	timezone: z.string()
+});
+const FuturesOrderBookSchema = z.object({
+	lastUpdateId: z.number(),
+	E: z.number(),
+	T: z.number(),
+	bids: z.array(z.tuple([z.coerce.number(), z.coerce.number()])),
+	asks: z.array(z.tuple([z.coerce.number(), z.coerce.number()]))
+});
+const FuturesRecentTradesSchema = z.array(z.object({
+	id: z.number(),
+	price: z.coerce.number(),
+	qty: z.coerce.number(),
+	quoteQty: z.coerce.number(),
+	time: z.number(),
+	isBuyerMaker: z.boolean()
+}));
+const FuturesOldTradesLookupSchema = z.array(z.object({
+	id: z.number(),
+	price: z.coerce.number(),
+	qty: z.coerce.number(),
+	quoteQty: z.coerce.number(),
+	time: z.number(),
+	isBuyerMaker: z.boolean()
+}));
+const FuturesAggregateTradesSchema = z.array(z.object({
+	a: z.number(),
+	p: z.coerce.number(),
+	q: z.coerce.number(),
+	f: z.number(),
+	l: z.number(),
+	T: z.number(),
+	m: z.boolean()
+}));
+const FuturesKlineDataSchema = z.array(z.tuple([
+	z.number(),
+	z.coerce.number(),
+	z.coerce.number(),
+	z.coerce.number(),
+	z.coerce.number(),
+	z.coerce.number(),
+	z.number(),
+	z.coerce.number(),
+	z.number(),
+	z.coerce.number(),
+	z.coerce.number(),
+	z.coerce.number()
+]));
+const FuturesMarkPriceSchema = z.object({
+	symbol: z.string(),
+	markPrice: z.coerce.number(),
+	indexPrice: z.coerce.number(),
+	estimatedSettlePrice: z.coerce.number(),
+	lastFundingRate: z.coerce.number(),
+	interestRate: z.coerce.number(),
+	nextFundingTime: z.number(),
+	time: z.number()
+});
+const FuturesFundingRateEntrySchema = z.object({
+	symbol: z.string(),
+	fundingRate: z.coerce.number(),
+	fundingTime: z.number(),
+	markPrice: z.coerce.number()
+});
+const FuturesFundingRateSchema = z.array(FuturesFundingRateEntrySchema);
+const FuturesFundingInfoEntrySchema = z.object({
+	symbol: z.string(),
+	adjustedFundingRateCap: z.coerce.number(),
+	adjustedFundingRateFloor: z.coerce.number(),
+	fundingIntervalHours: z.number()
+});
+const FuturesFundingInfoSchema = z.array(FuturesFundingInfoEntrySchema);
+const FuturesTicker24hSchema = z.object({
+	symbol: z.string(),
+	priceChange: z.coerce.number(),
+	priceChangePercent: z.coerce.number(),
+	weightedAvgPrice: z.coerce.number(),
+	lastPrice: z.coerce.number(),
+	lastQty: z.coerce.number(),
+	openPrice: z.coerce.number(),
+	highPrice: z.coerce.number(),
+	lowPrice: z.coerce.number(),
+	volume: z.coerce.number(),
+	quoteVolume: z.coerce.number(),
+	openTime: z.number(),
+	closeTime: z.number(),
+	firstId: z.number(),
+	lastId: z.number(),
+	count: z.number()
+});
+const FuturesSymbolPriceSchema = z.object({
+	symbol: z.string(),
+	price: z.coerce.number(),
+	time: z.number()
+});
+const FuturesBookTickerSchema = z.object({
+	symbol: z.string(),
+	bidPrice: z.coerce.number(),
+	bidQty: z.coerce.number(),
+	askPrice: z.coerce.number(),
+	askQty: z.coerce.number(),
+	time: z.coerce.number()
+});
+const FuturesDeliveryPriceSchema = z.array(z.object({
+	deliveryTime: z.coerce.number(),
+	deliveryPrice: z.coerce.number()
+}));
+const FuturesOpenInterestSchema = z.object({
+	openInterest: z.coerce.number(),
+	symbol: z.string(),
+	time: z.coerce.number()
+});
+const FuturesOpenInterestStatsSchema = z.array(z.object({
+	symbol: z.string(),
+	sumOpenInterest: z.coerce.number(),
+	sumOpenInterestValue: z.coerce.number(),
+	timestamp: z.coerce.number()
+}));
+const FuturesLongShortRatioSchema = z.array(z.object({
+	symbol: z.string(),
+	longShortRatio: z.coerce.number(),
+	longAccount: z.coerce.number(),
+	shortAccount: z.coerce.number(),
+	timestamp: z.coerce.number()
+}));
+const FuturesTakerBuySellRatioItemSchema = z.object({
+	buySellRatio: z.coerce.number(),
+	buyVol: z.coerce.number(),
+	sellVol: z.coerce.number(),
+	timestamp: z.coerce.number()
+});
+const FuturesTakerBuySellRatioSchema = z.array(FuturesTakerBuySellRatioItemSchema);
+const FuturesBasisSchema = z.array(z.object({
+	indexPrice: z.coerce.number(),
+	contractType: FuturesContractTypeSchema,
+	basisRate: z.coerce.number(),
+	futuresPrice: z.coerce.number(),
+	annualizedBasisRate: z.string().optional(),
+	basis: z.coerce.number(),
+	pair: z.string(),
+	timestamp: z.number()
+}));
+const FuturesCompositeIndexAssetSchema = z.object({
+	baseAsset: z.string(),
+	quoteAsset: z.string(),
+	weightInQuantity: z.coerce.number(),
+	weightInPercentage: z.coerce.number()
+});
+const FuturesCompositeIndexSchema = z.object({
+	symbol: z.string(),
+	time: z.coerce.number(),
+	component: z.string(),
+	baseAssetList: z.array(FuturesCompositeIndexAssetSchema)
+});
+const FuturesAssetIndexSchema = z.object({
+	symbol: z.string(),
+	time: z.coerce.number(),
+	index: z.coerce.number(),
+	bidBuffer: z.coerce.number(),
+	askBuffer: z.coerce.number(),
+	bidRate: z.coerce.number(),
+	askRate: z.coerce.number(),
+	autoExchangeBidBuffer: z.coerce.number(),
+	autoExchangeAskBuffer: z.coerce.number(),
+	autoExchangeBidRate: z.coerce.number(),
+	autoExchangeAskRate: z.coerce.number()
+});
+const FuturesIndexPriceConstituentItemSchema = z.object({
+	exchange: z.string(),
+	symbol: z.string(),
+	price: z.coerce.number(),
+	weight: z.coerce.number()
+});
+const FuturesIndexPriceConstituentsSchema = z.object({
+	symbol: z.string(),
+	time: z.coerce.number(),
+	constituents: z.array(FuturesIndexPriceConstituentItemSchema)
+});
+const FuturesInsuranceBalanceAssetSchema = z.object({
+	asset: z.string(),
+	marginBalance: z.coerce.number(),
+	updateTime: z.coerce.number()
+});
+const FuturesInsuranceBalanceEntrySchema = z.object({
+	symbols: z.array(z.string()),
+	assets: z.array(FuturesInsuranceBalanceAssetSchema)
+});
+const FuturesAccountBalanceSchema = z.array(z.object({
+	accountAlias: z.string(),
+	asset: z.string(),
+	balance: z.coerce.number(),
+	crossWalletBalance: z.coerce.number(),
+	crossUnPnl: z.coerce.number(),
+	availableBalance: z.coerce.number(),
+	maxWithdrawAmount: z.coerce.number(),
+	marginAvailable: z.boolean(),
+	updateTime: z.number()
+}));
+const FuturesAccountAssetSchema = z.object({
+	asset: z.string(),
+	walletBalance: z.coerce.number(),
+	unrealizedProfit: z.coerce.number(),
+	marginBalance: z.coerce.number(),
+	maintMargin: z.coerce.number(),
+	initialMargin: z.coerce.number(),
+	positionInitialMargin: z.coerce.number(),
+	openOrderInitialMargin: z.coerce.number(),
+	crossWalletBalance: z.coerce.number(),
+	crossUnPnl: z.coerce.number(),
+	availableBalance: z.coerce.number(),
+	maxWithdrawAmount: z.coerce.number(),
+	updateTime: z.number(),
+	marginAvailable: z.boolean().optional()
+});
+const FuturesAccountPositionSchema = z.object({
+	symbol: z.string(),
+	positionSide: z.string(),
+	positionAmt: z.coerce.number(),
+	unrealizedProfit: z.coerce.number(),
+	isolatedMargin: z.coerce.number(),
+	notional: z.coerce.number(),
+	isolatedWallet: z.coerce.number(),
+	initialMargin: z.coerce.number(),
+	maintMargin: z.coerce.number(),
+	updateTime: z.number()
+});
+const FuturesAccountInfoSchema = z.object({
+	totalInitialMargin: z.coerce.number(),
+	totalMaintMargin: z.coerce.number(),
+	totalWalletBalance: z.coerce.number(),
+	totalUnrealizedProfit: z.coerce.number(),
+	totalMarginBalance: z.coerce.number(),
+	totalPositionInitialMargin: z.coerce.number(),
+	totalOpenOrderInitialMargin: z.coerce.number(),
+	totalCrossWalletBalance: z.coerce.number(),
+	totalCrossUnPnl: z.coerce.number(),
+	availableBalance: z.coerce.number(),
+	maxWithdrawAmount: z.coerce.number(),
+	assets: z.array(FuturesAccountAssetSchema),
+	positions: z.array(FuturesAccountPositionSchema)
+});
+const FuturesCommissionRateSchema = z.object({
+	symbol: z.string(),
+	makerCommissionRate: z.coerce.number(),
+	takerCommissionRate: z.coerce.number()
+});
+const FuturesAccountConfigSchema = z.object({
+	feeTier: z.number(),
+	canTrade: z.boolean(),
+	canDeposit: z.boolean(),
+	canWithdraw: z.boolean(),
+	dualSidePosition: z.boolean(),
+	multiAssetsMargin: z.boolean(),
+	tradeGroupId: z.number()
+});
+const FuturesSymbolConfigSchema = z.array(z.object({
+	symbol: z.string(),
+	marginType: z.enum(["ISOLATED", "CROSSED"]),
+	isAutoAddMargin: z.boolean(),
+	leverage: z.coerce.number(),
+	maxNotionalValue: z.coerce.number().or(z.literal("INF")).transform((v) => v === "INF" ? Infinity : Number(v))
+}));
+const FuturesUserRateLimitSchema = z.array(z.object({
+	rateLimitType: z.literal("ORDERS"),
+	interval: z.enum([
+		"SECOND",
+		"MINUTE",
+		"DAY"
+	]),
+	intervalNum: z.number(),
+	limit: z.number()
+}));
+const FuturesLeverageBracketEntrySchema = z.object({
+	bracket: z.number(),
+	initialLeverage: z.number(),
+	notionalCap: z.number(),
+	notionalFloor: z.number(),
+	maintMarginRatio: z.number(),
+	cum: z.number()
+});
+const FuturesLeverageBracketSchema = z.array(z.object({
+	symbol: z.string(),
+	notionalCoef: z.number().optional(),
+	brackets: z.array(FuturesLeverageBracketEntrySchema)
+}));
+const FuturesPositionModeSchema = z.object({ dualSidePosition: z.boolean() });
+const FuturesIncomeTypeSchema = z.enum([
+	"TRANSFER",
+	"WELCOME_BONUS",
+	"REALIZED_PNL",
+	"FUNDING_FEE",
+	"COMMISSION",
+	"INSURANCE_CLEAR",
+	"REFERRAL_KICKBACK",
+	"COMMISSION_REBATE",
+	"API_REBATE",
+	"CONTEST_REWARD",
+	"CROSS_COLLATERAL_TRANSFER",
+	"OPTIONS_PREMIUM_FEE",
+	"OPTIONS_SETTLE_PROFIT",
+	"INTERNAL_TRANSFER",
+	"AUTO_EXCHANGE",
+	"DELIVERED_SETTELMENT",
+	"COIN_SWAP_DEPOSIT",
+	"COIN_SWAP_WITHDRAW",
+	"POSITION_LIMIT_INCREASE_FEE",
+	"STRATEGY_UMFUTURES_TRANSFER",
+	"FEE_RETURN",
+	"BFUSD_REWARD"
+]);
+const FuturesIncomeHistorySchema = z.array(z.object({
+	symbol: z.string().optional(),
+	incomeType: FuturesIncomeTypeSchema,
+	income: z.coerce.number(),
+	asset: z.string(),
+	info: z.string(),
+	time: z.number(),
+	tranId: z.number(),
+	tradeId: z.string().optional()
+}));
+const FuturesOrderSideSchema = z.enum(["BUY", "SELL"]);
+const FuturesPositionSideSchema = z.enum([
+	"BOTH",
+	"LONG",
+	"SHORT"
+]);
+const FuturesTimeInForceSchema = z.enum([
+	"GTC",
+	"IOC",
+	"FOK",
+	"GTX",
+	"GTD"
+]);
+const FuturesWorkingTypeSchema = z.enum(["MARK_PRICE", "CONTRACT_PRICE"]);
+const FuturesNewOrderRespTypeSchema = z.enum(["ACK", "RESULT"]);
+const FuturesPriceMatchSchema = z.enum([
+	"OPPONENT",
+	"OPPONENT_5",
+	"OPPONENT_10",
+	"OPPONENT_20",
+	"QUEUE",
+	"QUEUE_5",
+	"QUEUE_10",
+	"QUEUE_20",
+	"NONE"
+]);
+const FuturesSelfTradePreventionSchema = z.enum([
+	"NONE",
+	"EXPIRE_TAKER",
+	"EXPIRE_MAKER",
+	"EXPIRE_BOTH"
+]);
+const FuturesNewOrderSchema = z.object({
+	clientOrderId: z.string(),
+	cumQty: z.coerce.number(),
+	cumQuote: z.coerce.number(),
+	executedQty: z.coerce.number(),
+	orderId: z.number(),
+	avgPrice: z.coerce.number(),
+	origQty: z.coerce.number(),
+	price: z.coerce.number(),
+	reduceOnly: z.boolean(),
+	side: FuturesOrderSideSchema,
+	positionSide: FuturesPositionSideSchema,
+	status: z.string(),
+	stopPrice: z.coerce.number().optional(),
+	closePosition: z.boolean().optional(),
+	symbol: z.string(),
+	timeInForce: FuturesTimeInForceSchema,
+	type: FuturesOrderTypeSchema,
+	origType: FuturesOrderTypeSchema,
+	activatePrice: z.coerce.number().optional(),
+	priceRate: z.coerce.number().optional(),
+	updateTime: z.number(),
+	workingType: FuturesWorkingTypeSchema,
+	priceProtect: z.boolean(),
+	priceMatch: FuturesPriceMatchSchema.optional(),
+	selfTradePreventionMode: FuturesSelfTradePreventionSchema.optional(),
+	goodTillDate: z.number().optional()
+});
+
+//#endregion
+//#region src/shared/api-error.ts
+var ApiError = class extends Error {
+	endpoint;
+	constructor({ endpoint, metadata }) {
+		super(JSON.stringify({
+			endpoint,
+			...metadata
+		}, null, 2));
+		this.endpoint = endpoint;
+	}
+};
+var ValidationError = class extends ApiError {
+	error;
+	input;
+	constructor({ error, input, endpoint }) {
+		super({
+			endpoint,
+			metadata: {
+				error,
+				input
+			}
+		});
+		this.error = error;
+		this.input = input;
+	}
+};
+var ResponseError = class extends ApiError {
+	code;
+	status;
+	constructor({ metadata, code, status, endpoint }) {
+		super({
+			endpoint,
+			metadata: {
+				...metadata,
+				code,
+				status
+			}
+		});
+		this.code = code;
+		this.status = status;
+	}
+};
+var ErrorMessageParsingError = class extends Error {
+	constructor(message) {
+		super(message);
+	}
+};
+var WeightError = class extends ResponseError {
+	ip;
+	bannedUntil;
+	constructor({ message, endpoint }) {
+		super({
+			endpoint,
+			code: -1003,
+			status: 418
+		});
+		const { ip, timestamp } = this.parseWeightResponse(message);
+		this.ip = ip;
+		this.bannedUntil = timestamp;
+	}
+	parseWeightResponse(message) {
+		const match = message.match(/IP\(([^)]+)\).*?until (\d+)/);
+		if (!match) throw new ErrorMessageParsingError("Can't parse weight data");
+		const ip = String(match[1]);
+		const timestamp = Number(match[2]);
+		return {
+			ip,
+			timestamp
+		};
+	}
+};
+var MalformedParamError = class extends ResponseError {
+	param;
+	constructor({ message, endpoint }) {
+		super({
+			endpoint,
+			code: -1102,
+			status: 400
+		});
+		this.param = this.parseParam(message);
+	}
+	parseParam(message) {
+		const match = message.match(/'([^']+)'/);
+		if (match) console.log(match[1]);
+		if (!match) throw new ErrorMessageParsingError("Can't parse param data");
+		return String(match[1]);
+	}
+};
+
+//#endregion
+//#region src/shared/schema.ts
+const ErrorResponseSchema = z.object({
+	code: z.number(),
+	msg: z.string()
+});
+
+//#endregion
+//#region src/shared/base-rest-client.ts
+var BaseRestClient = class {
+	credentials;
+	httpCleint;
+	constructor({ baseUrl, credentials, httpOptions }) {
+		this.credentials = credentials;
+		this.httpCleint = new Client(baseUrl, {
+			allowH2: true,
+			...httpOptions
+		});
+	}
+	toSearchParams(rawParams) {
+		if (!rawParams) return {};
+		return Object.entries(rawParams).reduce((acc, [key, value]) => {
+			if (Array.isArray(value)) {
+				acc[key] = JSON.stringify(value);
+				return acc;
+			}
+			if (value !== void 0 && value !== null) acc[key] = String(value);
+			return acc;
+		}, {});
+	}
+	parseErrorResponse(endpoint, statusCode, json) {
+		const result = ErrorResponseSchema.safeParse(json);
+		if (result.error) throw new ApiError({
+			endpoint,
+			metadata: {
+				error: result.error,
+				json
+			}
+		});
+		switch (statusCode) {
+			case 418: throw new WeightError({
+				message: result.data.msg,
+				endpoint
+			});
+			case 400: throw new MalformedParamError({
+				endpoint,
+				message: result.data.msg
+			});
+			default: throw new ApiError({
+				endpoint,
+				metadata: { json }
+			});
+		}
+	}
+	async parseResponse(schema, response, endpoint) {
+		const json = await response.body.json();
+		if (response.statusCode === 200) {
+			const result = z4.safeParse(schema, json);
+			if (result.error) throw new ValidationError({
+				endpoint,
+				input: json,
+				error: result.error
+			});
+			return result.data;
+		}
+		throw this.parseErrorResponse(endpoint, response.statusCode, json);
+	}
+	async publicRequest({ endpoint, params, schema }) {
+		const searchParams = this.toSearchParams(params);
+		const response = await this.httpCleint.request({
+			method: "GET",
+			path: endpoint,
+			query: searchParams,
+			headers: { "X-MBX-APIKEY": this.credentials?.secret }
+		});
+		return this.parseResponse(schema, response, endpoint);
+	}
+	async privateRequest({ endpoint, params, schema, method }) {
+		if (!this.credentials) throw new ApiError({
+			endpoint,
+			metadata: { cause: "Empty credentials" }
+		});
+		const searchParams = this.toSearchParams(params);
+		if (this.credentials) {
+			searchParams["timestamp"] = (/* @__PURE__ */ new Date()).getTime().toString();
+			searchParams["signature"] = this.sign(new URLSearchParams(searchParams).toString(), this.credentials.secret);
+		}
+		const response = await this.httpCleint.request({
+			method,
+			path: endpoint,
+			query: method !== "POST" ? searchParams : void 0,
+			body: method === "POST" ? new URLSearchParams(searchParams).toString() : void 0,
+			headers: { "X-MBX-APIKEY": this.credentials?.key }
+		});
+		return this.parseResponse(schema, response, endpoint);
+	}
+	sign(message, secret) {
+		return createHmac("sha256", secret).update(message).digest("hex");
+	}
+};
+
+//#endregion
+//#region src/rest/futures/client.ts
+var FuturesRestClient = class extends BaseRestClient {
+	constructor({ baseUrl = "https://fapi.binance.com", credentials, httpOptions }) {
+		super({
+			baseUrl,
+			credentials,
+			httpOptions
+		});
+	}
+	async testConnectivity() {
+		return this.publicRequest({
+			endpoint: "/fapi/v1/ping",
+			schema: FuturesTestConnectivitySchema
+		});
+	}
+	async checkServerTime() {
+		return this.publicRequest({
+			endpoint: "/fapi/v1/time",
+			schema: FuturesCheckServerTimeSchema
+		});
+	}
+	async exchangeInformation() {
+		return this.publicRequest({
+			endpoint: "/fapi/v1/exchangeInfo",
+			schema: FuturesExchangeInfoSchema
+		});
+	}
+	async orderBook(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/depth",
+			schema: FuturesOrderBookSchema
+		});
+	}
+	async recentTrades(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/trades",
+			schema: FuturesRecentTradesSchema
+		});
+	}
+	async oldTradesLookup(params) {
+		return this.privateRequest({
+			method: "GET",
+			params,
+			endpoint: "/fapi/v1/historicalTrades",
+			schema: FuturesOldTradesLookupSchema
+		});
+	}
+	async aggregateTrades(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/aggTrades",
+			schema: FuturesAggregateTradesSchema
+		});
+	}
+	async klineData(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/klines",
+			schema: FuturesKlineDataSchema
+		});
+	}
+	async continuousContractKlineData(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/continuousKlines",
+			schema: FuturesKlineDataSchema
+		});
+	}
+	async indexPriceKlineData(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/indexPriceKlines",
+			schema: FuturesKlineDataSchema
+		});
+	}
+	async markPriceKlineData(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/markPriceKlines",
+			schema: FuturesKlineDataSchema
+		});
+	}
+	async premiumIndexKlineData(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/premiumIndexKlines",
+			schema: FuturesKlineDataSchema
+		});
+	}
+	async markPrice(params) {
+		const isSingle = !!params?.symbol;
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/premiumIndex",
+			schema: isSingle ? FuturesMarkPriceSchema : z$1.array(FuturesMarkPriceSchema)
+		});
+	}
+	async fundingRateHistory(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/fundingRate",
+			schema: FuturesFundingRateSchema
+		});
+	}
+	async fundingRateInfo() {
+		return this.publicRequest({
+			endpoint: "/fapi/v1/fundingInfo",
+			schema: FuturesFundingInfoSchema
+		});
+	}
+	async ticker24h(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/ticker/24hr",
+			schema: params?.symbol ? FuturesTicker24hSchema : z$1.array(FuturesTicker24hSchema)
+		});
+	}
+	async symbolPriceTicker(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v2/ticker/price",
+			schema: params?.symbol ? FuturesSymbolPriceSchema : z$1.array(FuturesSymbolPriceSchema)
+		});
+	}
+	async bookTicker(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/ticker/bookTicker",
+			schema: params?.symbol ? FuturesBookTickerSchema : z$1.array(FuturesBookTickerSchema)
+		});
+	}
+	async quarterlySettlementPrices(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/futures/data/delivery-price",
+			schema: FuturesDeliveryPriceSchema
+		});
+	}
+	async openInterest(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/openInterest",
+			schema: FuturesOpenInterestSchema
+		});
+	}
+	async openInterestStats(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/futures/data/openInterestHist",
+			schema: FuturesOpenInterestStatsSchema
+		});
+	}
+	async topLongShortPositionRatio(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/futures/data/topLongShortPositionRatio",
+			schema: FuturesLongShortRatioSchema
+		});
+	}
+	async topLongShortAccountRatio(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/futures/data/topLongShortAccountRatio",
+			schema: FuturesLongShortRatioSchema
+		});
+	}
+	async globalLongShortAccountRatio(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/futures/data/globalLongShortAccountRatio",
+			schema: FuturesLongShortRatioSchema
+		});
+	}
+	async takerBuySellRatio(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/futures/data/takerlongshortRatio",
+			schema: FuturesTakerBuySellRatioSchema
+		});
+	}
+	async basisData(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/futures/data/basis",
+			schema: FuturesBasisSchema
+		});
+	}
+	async compositeIndexInfo(params) {
+		const isSingle = !!params?.symbol;
+		return await this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/indexInfo",
+			schema: isSingle ? FuturesCompositeIndexSchema : z$1.array(FuturesCompositeIndexSchema)
+		});
+	}
+	async assetIndex(params) {
+		return await this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/assetIndex",
+			schema: params?.symbol ? FuturesAssetIndexSchema : z$1.array(FuturesAssetIndexSchema)
+		});
+	}
+	async indexPriceConstituents(params) {
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/constituents",
+			schema: FuturesIndexPriceConstituentsSchema
+		});
+	}
+	async insuranceBalance(params) {
+		const isSingle = !!params?.symbol;
+		return this.publicRequest({
+			params,
+			endpoint: "/fapi/v1/insuranceBalance",
+			schema: isSingle ? FuturesInsuranceBalanceEntrySchema : z$1.array(FuturesInsuranceBalanceEntrySchema)
+		});
+	}
+	async accountBalance() {
+		return this.privateRequest({
+			method: "GET",
+			endpoint: "/fapi/v3/balance",
+			schema: FuturesAccountBalanceSchema
+		});
+	}
+	async accountInformation() {
+		return this.privateRequest({
+			method: "GET",
+			endpoint: "/fapi/v3/account",
+			schema: FuturesAccountInfoSchema
+		});
+	}
+	async userCommissionRate(params) {
+		return this.privateRequest({
+			method: "GET",
+			endpoint: "/fapi/v1/commissionRate",
+			params,
+			schema: FuturesCommissionRateSchema
+		});
+	}
+	async accountConfig() {
+		return this.privateRequest({
+			method: "GET",
+			endpoint: "/fapi/v1/accountConfig",
+			schema: FuturesAccountConfigSchema
+		});
+	}
+	async symbolConfig(params) {
+		return this.privateRequest({
+			method: "GET",
+			endpoint: "/fapi/v1/symbolConfig",
+			params,
+			schema: FuturesSymbolConfigSchema
+		});
+	}
+	async userRateLimit() {
+		return this.privateRequest({
+			method: "GET",
+			endpoint: "/fapi/v1/rateLimit/order",
+			schema: FuturesUserRateLimitSchema
+		});
+	}
+	async leverageBrackets(params) {
+		return this.privateRequest({
+			method: "GET",
+			endpoint: "/fapi/v1/leverageBracket",
+			params,
+			schema: FuturesLeverageBracketSchema
+		});
+	}
+	async positionMode() {
+		return this.privateRequest({
+			method: "GET",
+			endpoint: "/fapi/v1/positionSide/dual",
+			schema: FuturesPositionModeSchema
+		});
+	}
+	async incomeHistory(params) {
+		return this.privateRequest({
+			method: "GET",
+			endpoint: "/fapi/v1/income",
+			params,
+			schema: FuturesIncomeHistorySchema
+		});
+	}
+	async newOrder(params) {
+		return this.privateRequest({
+			method: "POST",
+			endpoint: "/fapi/v1/order",
+			params,
+			schema: FuturesNewOrderSchema
+		});
+	}
+};
+
+//#endregion
+//#region src/rest/spot/schema.ts
+const SpotTestConnectivitySchema = z.object({});
+const SpotCheckServerTimeSchema = z.object({ serverTime: z.number() });
+
+//#endregion
+//#region src/rest/spot/client.ts
+var SpotRestClient = class extends BaseRestClient {
+	constructor({ baseUrl = "https://api.binance.com", credentials, httpOptions }) {
+		super({
+			baseUrl,
+			credentials,
+			httpOptions
+		});
+	}
+	async testConnectivity() {
+		return this.publicRequest({
+			endpoint: "/api/v3/ping",
+			schema: SpotTestConnectivitySchema
+		});
+	}
+	async checkServerTime() {
+		return this.publicRequest({
+			endpoint: "/api/v3/time",
+			schema: SpotCheckServerTimeSchema
+		});
+	}
+};
+
+//#endregion
+//#region src/rest/client.ts
+var BinanceRestClient = class {
+	futures;
+	spot;
+	constructor(options) {
+		this.futures = new FuturesRestClient({
+			credentials: options?.credentials,
+			baseUrl: options?.baseUrls?.futures
+		});
+		this.spot = new SpotRestClient({
+			credentials: options?.credentials,
+			baseUrl: options?.baseUrls?.spot
+		});
+	}
+};
+
+//#endregion
+//#region src/websocket/typed-event-emitter.ts
+var Emitter = class {
+	eventTarget = new EventTarget();
+	addEventListener(event, callback, options) {
+		this.eventTarget.addEventListener(event, (event$1) => callback(...event$1.detail), options);
+	}
+	emit(event, ...data) {
+		this.eventTarget.dispatchEvent(new CustomEvent(event, { detail: data }));
+	}
+};
+
+//#endregion
+//#region src/websocket/base/client.ts
+var BinanceWebsocketClient = class {
+	socket;
+	baseUrl;
+	emitter = new Emitter();
+	subscriptionId = 1;
+	subscriptions = /* @__PURE__ */ new Map();
+	constructor(baseUrl) {
+		this.parseEvent = this.parseEvent.bind(this);
+		this.baseUrl = baseUrl;
+		this.socket = this.createSocket();
+	}
+	createSocket() {
+		if (this.socket) {
+			this.socket.removeEventListener("message", this.parseEvent);
+			this.socket.close();
+		}
+		const socket = new WebSocket(this.baseUrl);
+		socket.addEventListener("message", this.parseEvent);
+		return socket;
+	}
+	sendMessage(data) {
+		this.socket.send(JSON.stringify(data));
+	}
+	parseEvent(e) {
+		if (typeof e.data !== "string") {
+			this.emitter.emit("error", new Error("Message event is not a string", { cause: e.data }));
+			return;
+		}
+		const data = JSON.parse(e.data);
+		if ("id" in data) this.emitter.emit("connectionMessage", data);
+		else this.emitter.emit("marketMessage", data);
+	}
+	async subscribe(...channels) {
+		await this.connect();
+		const pendingChannels = [];
+		for (const channel of channels) if (!this.subscriptions.get(channel)) {
+			pendingChannels.push(channel);
+			this.subscriptions.set(channel, "PENDING_SUBSCRIPTION");
+		}
+		const id = this.subscriptionId;
+		const data = {
+			method: "SUBSCRIBE",
+			params: pendingChannels,
+			id
+		};
+		this.subscriptionId += 1;
+		this.sendMessage(data);
+		return new Promise((resolve, reject) => {
+			const controller = new AbortController();
+			const handler = (data$1) => {
+				if (data$1.id !== id) return;
+				controller.abort();
+				if ("error" in data$1) {
+					for (const channel of pendingChannels) if (this.subscriptions.get(channel) === "PENDING_SUBSCRIPTION") this.subscriptions.delete(channel);
+					this.emitter.emit("error", data$1);
+					reject(/* @__PURE__ */ new Error(`Subscription ${id} failed`));
+				} else {
+					pendingChannels.forEach((channel) => this.subscriptions.set(channel, "SUBSCRIBED"));
+					resolve();
+				}
+			};
+			this.emitter.addEventListener("connectionMessage", handler, { signal: controller.signal });
+		});
+	}
+	async unsubscribe(...channels) {
+		await this.connect();
+	}
+	async reconnect() {
+		this.socket = this.createSocket();
+		await this.connect();
+		const toRestore = [];
+		for (const [channel, state] of this.subscriptions) if (state !== "PENDING_UNSUBSCRIPTION") toRestore.push(channel);
+		if (toRestore.length) await this.subscribe(...toRestore);
+	}
+	async connect() {
+		if (this.socket.readyState === WebSocket.OPEN) return;
+		if (this.socket.readyState === WebSocket.CONNECTING) return new Promise((resolve, reject) => {
+			this.socket.addEventListener("open", () => resolve(), { once: true });
+			this.socket.addEventListener("close", () => reject(), { once: true });
+		});
+		return this.reconnect();
+	}
+	addEventListener(event, callback, options) {
+		this.emitter.addEventListener(event, callback, options);
+	}
+};
+
+//#endregion
+//#region src/websocket/futures/client.ts
+var FuturesWebsocketClient = class extends BinanceWebsocketClient {
+	constructor(baseUrl = "wss://stream.binance.com:9443/ws") {
+		super(baseUrl);
+	}
+};
+
+//#endregion
+export { ApiError, BinanceRestClient, ErrorMessageParsingError, FuturesWebsocketClient, MalformedParamError, ResponseError, ValidationError, WeightError };