@medievalrain/binance-ts 0.7.0 → 0.9.6

package/dist/index.js

@@ -1,505 +1,6 @@
-import z$1, { z } from "zod";
-import { Client, WebSocket } from "undici";
-import * as z4 from "zod/v4/core";
 import { createHmac } from "node:crypto";
 import { createEmitter } from "@medievalrain/emitter";
 
-//#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;
@@ -511,21 +12,6 @@ var ApiError = class extends Error {
 		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;
@@ -563,11 +49,9 @@ var WeightError = class extends ResponseError {
 	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
+			ip: String(match[1]),
+			timestamp: Number(match[2])
 		};
 	}
 };
@@ -588,59 +72,73 @@ var MalformedParamError = class extends ResponseError {
 	}
 };
 
-//#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 {
-	httpCleint;
 	apiKey;
 	apiSecret;
-	constructor({ baseUrl, apiKey, apiSecret, httpOptions }) {
+	baseUrl;
+	constructor({ baseUrl, apiKey, apiSecret }) {
 		this.apiKey = apiKey;
 		this.apiSecret = apiSecret;
-		this.httpCleint = new Client(baseUrl, {
-			allowH2: true,
-			connect: {
-				maxVersion: "TLSv1.2",
-				...httpOptions?.connect
-			},
-			...httpOptions
+		this.baseUrl = baseUrl;
+	}
+	marketRequest = async ({ endpoint, params }) => {
+		const searchParams = this.toSearchParams(params);
+		const url = new URL(endpoint, this.baseUrl);
+		url.search = searchParams.toString();
+		const response = await fetch(url.toString(), { keepalive: true });
+		const json = await response.json();
+		if (response.status === 200) return json;
+		throw this.parseErrorResponse(endpoint, response.status, json);
+	};
+	async privateRequest({ endpoint, params, method }) {
+		if (!this.apiKey || !this.apiSecret) throw new ApiError({
+			endpoint,
+			metadata: { cause: "Empty credentials" }
 		});
+		const searchParams = this.toSearchParams(params);
+		searchParams.append("timestamp", (/* @__PURE__ */ new Date()).getTime().toString());
+		const signature = this.sign(searchParams.toString(), this.apiSecret);
+		searchParams.append("signature", signature);
+		const url = new URL(endpoint, this.baseUrl);
+		const requestOptions = {
+			keepalive: true,
+			headers: { "X-MBX-APIKEY": this.apiKey },
+			method
+		};
+		if (method === "POST") requestOptions.body = searchParams.toString();
+		else url.search = searchParams.toString();
+		const response = await fetch(url.toString(), requestOptions);
+		const json = await response.json();
+		if (response.status === 200) return json;
+		throw this.parseErrorResponse(endpoint, response.status, json);
+	}
+	sign(message, secret) {
+		return createHmac("sha256", secret).update(message).digest("hex");
 	}
 	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;
-		}, {});
+		const searchParams = new URLSearchParams();
+		if (!rawParams) return searchParams;
+		for (const [key, value] of Object.entries(rawParams)) {
+			if (Array.isArray(value)) searchParams.append(key, JSON.stringify(value));
+			if (value !== void 0 && value !== null) searchParams.append(key, String(value));
+		}
+		return searchParams;
 	}
 	parseErrorResponse(endpoint, statusCode, json) {
-		const result = ErrorResponseSchema.safeParse(json);
-		if (result.error) throw new ApiError({
+		if (!json.code || !json.msg) throw new ApiError({
 			endpoint,
-			metadata: {
-				error: result.error,
-				json
-			}
+			metadata: { json }
 		});
 		switch (statusCode) {
 			case 418: throw new WeightError({
-				message: result.data.msg,
+				message: json.msg,
 				endpoint
 			});
 			case 400: throw new MalformedParamError({
 				endpoint,
-				message: result.data.msg
+				message: json.msg
 			});
 			default: throw new ApiError({
 				endpoint,
@@ -648,376 +146,275 @@ var BaseRestClient = class {
 			});
 		}
 	}
-	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.apiKey }
-		});
-		return this.parseResponse(schema, response, endpoint);
-	}
-	async privateRequest({ endpoint, params, schema, method }) {
-		if (!this.apiKey || !this.apiSecret) throw new ApiError({
-			endpoint,
-			metadata: { cause: "Empty credentials" }
-		});
-		const searchParams = this.toSearchParams(params);
-		searchParams["timestamp"] = (/* @__PURE__ */ new Date()).getTime().toString();
-		searchParams["signature"] = this.sign(new URLSearchParams(searchParams).toString(), this.apiSecret);
-		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.apiKey }
-		});
-		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", apiKey, apiSecret, httpOptions }) {
+	constructor({ baseUrl = "https://fapi.binance.com", apiKey, apiSecret }) {
 		super({
 			baseUrl,
 			apiKey,
-			apiSecret,
-			httpOptions
+			apiSecret
 		});
 	}
 	async testConnectivity() {
-		return this.publicRequest({
-			endpoint: "/fapi/v1/ping",
-			schema: FuturesTestConnectivitySchema
-		});
+		return this.marketRequest({ endpoint: "/fapi/v1/ping" });
 	}
 	async checkServerTime() {
-		return this.publicRequest({
-			endpoint: "/fapi/v1/time",
-			schema: FuturesCheckServerTimeSchema
-		});
+		return this.marketRequest({ endpoint: "/fapi/v1/time" });
 	}
 	async exchangeInformation() {
-		return this.publicRequest({
-			endpoint: "/fapi/v1/exchangeInfo",
-			schema: FuturesExchangeInfoSchema
-		});
+		return this.marketRequest({ endpoint: "/fapi/v1/exchangeInfo" });
 	}
 	async orderBook(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/depth",
-			schema: FuturesOrderBookSchema
+			endpoint: "/fapi/v1/depth"
 		});
 	}
 	async recentTrades(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/trades",
-			schema: FuturesRecentTradesSchema
+			endpoint: "/fapi/v1/trades"
 		});
 	}
 	async oldTradesLookup(params) {
 		return this.privateRequest({
 			method: "GET",
 			params,
-			endpoint: "/fapi/v1/historicalTrades",
-			schema: FuturesOldTradesLookupSchema
+			endpoint: "/fapi/v1/historicalTrades"
 		});
 	}
 	async aggregateTrades(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/aggTrades",
-			schema: FuturesAggregateTradesSchema
+			endpoint: "/fapi/v1/aggTrades"
 		});
 	}
 	async klineData(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/klines",
-			schema: FuturesKlineDataSchema
+			endpoint: "/fapi/v1/klines"
 		});
 	}
 	async continuousContractKlineData(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/continuousKlines",
-			schema: FuturesKlineDataSchema
+			endpoint: "/fapi/v1/continuousKlines"
 		});
 	}
 	async indexPriceKlineData(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/indexPriceKlines",
-			schema: FuturesKlineDataSchema
+			endpoint: "/fapi/v1/indexPriceKlines"
 		});
 	}
 	async markPriceKlineData(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/markPriceKlines",
-			schema: FuturesKlineDataSchema
+			endpoint: "/fapi/v1/markPriceKlines"
 		});
 	}
 	async premiumIndexKlineData(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/premiumIndexKlines",
-			schema: FuturesKlineDataSchema
+			endpoint: "/fapi/v1/premiumIndexKlines"
 		});
 	}
 	async markPrice(params) {
-		const isSingle = !!params?.symbol;
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/premiumIndex",
-			schema: isSingle ? FuturesMarkPriceSchema : z$1.array(FuturesMarkPriceSchema)
+			endpoint: "/fapi/v1/premiumIndex"
 		});
 	}
 	async fundingRateHistory(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/fundingRate",
-			schema: FuturesFundingRateSchema
+			endpoint: "/fapi/v1/fundingRate"
 		});
 	}
 	async fundingRateInfo() {
-		return this.publicRequest({
-			endpoint: "/fapi/v1/fundingInfo",
-			schema: FuturesFundingInfoSchema
-		});
+		return this.marketRequest({ endpoint: "/fapi/v1/fundingInfo" });
 	}
 	async ticker24h(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/ticker/24hr",
-			schema: params?.symbol ? FuturesTicker24hSchema : z$1.array(FuturesTicker24hSchema)
+			endpoint: "/fapi/v1/ticker/24hr"
 		});
 	}
 	async symbolPriceTicker(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v2/ticker/price",
-			schema: params?.symbol ? FuturesSymbolPriceSchema : z$1.array(FuturesSymbolPriceSchema)
+			endpoint: "/fapi/v2/ticker/price"
 		});
 	}
 	async bookTicker(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/ticker/bookTicker",
-			schema: params?.symbol ? FuturesBookTickerSchema : z$1.array(FuturesBookTickerSchema)
+			endpoint: "/fapi/v1/ticker/bookTicker"
 		});
 	}
 	async quarterlySettlementPrices(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/futures/data/delivery-price",
-			schema: FuturesDeliveryPriceSchema
+			endpoint: "/futures/data/delivery-price"
 		});
 	}
 	async openInterest(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/openInterest",
-			schema: FuturesOpenInterestSchema
+			endpoint: "/fapi/v1/openInterest"
 		});
 	}
 	async openInterestStats(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/futures/data/openInterestHist",
-			schema: FuturesOpenInterestStatsSchema
+			endpoint: "/futures/data/openInterestHist"
 		});
 	}
 	async topLongShortPositionRatio(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/futures/data/topLongShortPositionRatio",
-			schema: FuturesLongShortRatioSchema
+			endpoint: "/futures/data/topLongShortPositionRatio"
 		});
 	}
 	async topLongShortAccountRatio(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/futures/data/topLongShortAccountRatio",
-			schema: FuturesLongShortRatioSchema
+			endpoint: "/futures/data/topLongShortAccountRatio"
 		});
 	}
 	async globalLongShortAccountRatio(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/futures/data/globalLongShortAccountRatio",
-			schema: FuturesLongShortRatioSchema
+			endpoint: "/futures/data/globalLongShortAccountRatio"
 		});
 	}
 	async takerBuySellRatio(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/futures/data/takerlongshortRatio",
-			schema: FuturesTakerBuySellRatioSchema
+			endpoint: "/futures/data/takerlongshortRatio"
 		});
 	}
 	async basisData(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/futures/data/basis",
-			schema: FuturesBasisSchema
+			endpoint: "/futures/data/basis"
 		});
 	}
 	async compositeIndexInfo(params) {
-		const isSingle = !!params?.symbol;
-		return await this.publicRequest({
+		return await this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/indexInfo",
-			schema: isSingle ? FuturesCompositeIndexSchema : z$1.array(FuturesCompositeIndexSchema)
+			endpoint: "/fapi/v1/indexInfo"
 		});
 	}
 	async assetIndex(params) {
-		return await this.publicRequest({
+		return await this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/assetIndex",
-			schema: params?.symbol ? FuturesAssetIndexSchema : z$1.array(FuturesAssetIndexSchema)
+			endpoint: "/fapi/v1/assetIndex"
 		});
 	}
 	async indexPriceConstituents(params) {
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/constituents",
-			schema: FuturesIndexPriceConstituentsSchema
+			endpoint: "/fapi/v1/constituents"
 		});
 	}
 	async insuranceBalance(params) {
-		const isSingle = !!params?.symbol;
-		return this.publicRequest({
+		return this.marketRequest({
 			params,
-			endpoint: "/fapi/v1/insuranceBalance",
-			schema: isSingle ? FuturesInsuranceBalanceEntrySchema : z$1.array(FuturesInsuranceBalanceEntrySchema)
+			endpoint: "/fapi/v1/insuranceBalance"
 		});
 	}
 	async accountBalance() {
 		return this.privateRequest({
 			method: "GET",
-			endpoint: "/fapi/v3/balance",
-			schema: FuturesAccountBalanceSchema
+			endpoint: "/fapi/v3/balance"
 		});
 	}
 	async accountInformation() {
 		return this.privateRequest({
 			method: "GET",
-			endpoint: "/fapi/v3/account",
-			schema: FuturesAccountInfoSchema
+			endpoint: "/fapi/v3/account"
 		});
 	}
 	async userCommissionRate(params) {
 		return this.privateRequest({
 			method: "GET",
 			endpoint: "/fapi/v1/commissionRate",
-			params,
-			schema: FuturesCommissionRateSchema
+			params
 		});
 	}
 	async accountConfig() {
 		return this.privateRequest({
 			method: "GET",
-			endpoint: "/fapi/v1/accountConfig",
-			schema: FuturesAccountConfigSchema
+			endpoint: "/fapi/v1/accountConfig"
 		});
 	}
 	async symbolConfig(params) {
 		return this.privateRequest({
 			method: "GET",
 			endpoint: "/fapi/v1/symbolConfig",
-			params,
-			schema: FuturesSymbolConfigSchema
+			params
 		});
 	}
 	async userRateLimit() {
 		return this.privateRequest({
 			method: "GET",
-			endpoint: "/fapi/v1/rateLimit/order",
-			schema: FuturesUserRateLimitSchema
+			endpoint: "/fapi/v1/rateLimit/order"
 		});
 	}
 	async leverageBrackets(params) {
 		return this.privateRequest({
 			method: "GET",
 			endpoint: "/fapi/v1/leverageBracket",
-			params,
-			schema: FuturesLeverageBracketSchema
+			params
 		});
 	}
 	async positionMode() {
 		return this.privateRequest({
 			method: "GET",
-			endpoint: "/fapi/v1/positionSide/dual",
-			schema: FuturesPositionModeSchema
+			endpoint: "/fapi/v1/positionSide/dual"
 		});
 	}
 	async incomeHistory(params) {
 		return this.privateRequest({
 			method: "GET",
 			endpoint: "/fapi/v1/income",
-			params,
-			schema: FuturesIncomeHistorySchema
+			params
 		});
 	}
 	async newOrder(params) {
 		return this.privateRequest({
 			method: "POST",
 			endpoint: "/fapi/v1/order",
-			params,
-			schema: FuturesNewOrderSchema
+			params
+		});
+	}
+	async getListenKey() {
+		return this.privateRequest({
+			method: "POST",
+			endpoint: "/fapi/v1/listenKey"
 		});
 	}
 };
 
-//#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", apiKey, apiSecret, httpOptions }) {
+	constructor({ baseUrl = "https://api.binance.com", apiKey, apiSecret }) {
 		super({
 			baseUrl,
 			apiKey,
-			apiSecret,
-			httpOptions
+			apiSecret
 		});
 	}
 	async testConnectivity() {
-		return this.publicRequest({
-			endpoint: "/api/v3/ping",
-			schema: SpotTestConnectivitySchema
-		});
+		return this.marketRequest({ endpoint: "/api/v3/ping" });
 	}
 	async checkServerTime() {
-		return this.publicRequest({
-			endpoint: "/api/v3/time",
-			schema: SpotCheckServerTimeSchema
-		});
+		return this.marketRequest({ endpoint: "/api/v3/time" });
 	}
 };
 
@@ -1064,8 +461,7 @@ const makeSection = (baseUrl) => {
 				connectionController = new AbortController();
 				socket.addEventListener("message", parseMessageEvent, { signal: connectionController.signal });
 				connectionId = 1;
-				const toSubscribe = Array.from(subscriptions.entries()).filter(([_, state]) => state !== "PENDING_UNSUBSCRIPTION").map(([key]) => key);
-				return subscribe(toSubscribe);
+				return subscribe(Array.from(subscriptions.entries()).filter(([_, state]) => state !== "PENDING_UNSUBSCRIPTION").map(([key]) => key));
 			}
 			if (socket.readyState === WebSocket.CONNECTING) socket.addEventListener("open", () => resolve(), { once: true });
 			if (socket.readyState === WebSocket.CLOSING) socket.addEventListener("close", async () => {
@@ -1198,6 +594,9 @@ const symbolConverter = {
 	partialBookDepth: (symbol, { levels, updateSpeedMs }) => {
 		if (updateSpeedMs) return `${symbol.toLowerCase()}@depth${levels}@${updateSpeedMs}ms`;
 		return `${symbol.toLowerCase()}@depth${levels}`;
+	},
+	aggTrade: (symbol) => {
+		return `${symbol.toLowerCase()}@aggTrade`;
 	}
 };
 const createFuturesWebsocketClient = (baseUrl = "wss://stream.binance.com:9443/ws") => {
@@ -1205,4 +604,4 @@ const createFuturesWebsocketClient = (baseUrl = "wss://stream.binance.com:9443/w
 };
 
 //#endregion
-export { ApiError, BinanceRestClient, ErrorMessageParsingError, MalformedParamError, ResponseError, ValidationError, WeightError, createFuturesWebsocketClient };
+export { ApiError, BinanceRestClient, ErrorMessageParsingError, MalformedParamError, ResponseError, WeightError, createFuturesWebsocketClient };