binance-futures-wrapper
Version:
A comprehensive TypeScript wrapper for Binance USDT-M Futures API with full REST and WebSocket support
301 lines • 9.52 kB
JavaScript
"use strict";
/**
* WebSocket Data Converter
* Converts raw WebSocket data to user-friendly processed types
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.convertUserDataEvent = convertUserDataEvent;
exports.convertMarketDataEvent = convertMarketDataEvent;
exports.isUserDataEvent = isUserDataEvent;
exports.isMarketDataEvent = isMarketDataEvent;
/**
* Convert raw user data stream events to processed format
*/
function convertUserDataEvent(rawData) {
switch (rawData.e) {
case 'ORDER_TRADE_UPDATE':
return convertOrderUpdate(rawData);
case 'ACCOUNT_UPDATE':
return convertAccountUpdate(rawData);
case 'ACCOUNT_CONFIG_UPDATE':
return convertAccountConfigUpdate(rawData);
case 'MARGIN_CALL':
return convertMarginCall(rawData);
default:
throw new Error(`Unknown user data event type: ${rawData.e}`);
}
}
/**
* Convert raw market data stream events to processed format
*/
function convertMarketDataEvent(rawData) {
// Handle events that have 'e' property
if ('e' in rawData) {
switch (rawData.e) {
case 'aggTrade':
return convertAggTrade(rawData);
case 'markPriceUpdate':
return convertMarkPrice(rawData);
case 'kline':
return convertKline(rawData);
case '24hrTicker':
return convertTicker(rawData);
case 'bookTicker':
return convertBookTicker(rawData);
case 'depthUpdate':
return convertPartialBookDepth(rawData);
default:
throw new Error(`Unknown market data event type: ${rawData.e}`);
}
}
// Handle special cases without 'e' property
throw new Error(`Unable to process market data event: ${JSON.stringify(rawData)}`);
}
/**
* Convert ORDER_TRADE_UPDATE to processed format
*/
function convertOrderUpdate(data) {
return {
eventType: 'ORDER_TRADE_UPDATE',
eventTime: data.E,
transactionTime: data.T,
symbol: data.o.s,
clientOrderId: data.o.c,
side: data.o.S,
orderType: data.o.o,
timeInForce: data.o.f,
originalQuantity: parseFloat(data.o.q),
originalPrice: parseFloat(data.o.p),
averagePrice: parseFloat(data.o.ap),
stopPrice: parseFloat(data.o.sp),
executionType: data.o.x,
orderStatus: data.o.X,
orderId: data.o.i,
lastFilledQuantity: parseFloat(data.o.l),
totalFilledQuantity: parseFloat(data.o.z),
lastFilledPrice: parseFloat(data.o.L),
commissionAsset: data.o.N || undefined,
commission: data.o.n ? parseFloat(data.o.n) : undefined,
orderTradeTime: data.o.T,
tradeId: data.o.t,
bidsNotional: parseFloat(data.o.b),
asksNotional: parseFloat(data.o.a),
isMakerSide: data.o.m,
isReduceOnly: data.o.R,
stopPriceWorkingType: data.o.wt,
originalOrderType: data.o.ot,
positionSide: data.o.ps,
isCloseAll: data.o.cp,
activationPrice: data.o.AP ? parseFloat(data.o.AP) : undefined,
callbackRate: data.o.cr ? parseFloat(data.o.cr) : undefined,
isPriceProtectionOn: data.o.pP,
realizedProfit: parseFloat(data.o.rp),
};
}
/**
* Convert ACCOUNT_UPDATE to processed format
*/
function convertAccountUpdate(data) {
const balances = data.a.B.map(balance => ({
asset: balance.a,
walletBalance: parseFloat(balance.wb),
crossWalletBalance: parseFloat(balance.cw),
balanceChange: parseFloat(balance.bc)
}));
const positions = data.a.P.map(position => ({
symbol: position.s,
positionAmount: parseFloat(position.pa),
entryPrice: parseFloat(position.ep),
accumulatedRealized: parseFloat(position.cr),
unrealizedPnL: parseFloat(position.up),
marginType: position.mt,
isolatedWallet: parseFloat(position.iw),
positionSide: position.ps
}));
return {
eventType: 'ACCOUNT_UPDATE',
eventTime: data.E,
transactionTime: data.T,
eventReasonType: data.a.m,
balances,
positions
};
}
/**
* Convert ACCOUNT_CONFIG_UPDATE to processed format
*/
function convertAccountConfigUpdate(data) {
return {
eventType: 'ACCOUNT_CONFIG_UPDATE',
eventTime: data.E,
transactionTime: data.T,
leverageUpdate: data.ac ? {
symbol: data.ac.s,
leverage: data.ac.l
} : undefined,
multiAssetsMode: data.ai ? {
multiAssetsMode: data.ai.j
} : undefined
};
}
/**
* Convert MARGIN_CALL to processed format
*/
function convertMarginCall(data) {
const positions = data.p.map(position => ({
symbol: position.s,
positionSide: position.ps,
positionAmount: parseFloat(position.pa),
marginType: position.mt,
isolatedWallet: parseFloat(position.iw),
markPrice: parseFloat(position.mp),
unrealizedPnL: parseFloat(position.up),
maintenanceMarginRequired: parseFloat(position.mm)
}));
return {
eventType: 'MARGIN_CALL',
eventTime: data.E,
crossWalletBalance: parseFloat(data.cw),
positions
};
}
/**
* Convert aggTrade to processed format
*/
function convertAggTrade(data) {
return {
eventType: 'aggTrade',
eventTime: data.E,
symbol: data.s,
aggregateTradeId: data.a,
price: parseFloat(data.p),
quantity: parseFloat(data.q),
firstTradeId: data.f,
lastTradeId: data.l,
tradeTime: data.T,
isBuyerMaker: data.m
};
}
/**
* Convert markPriceUpdate to processed format
*/
function convertMarkPrice(data) {
return {
eventType: 'markPriceUpdate',
eventTime: data.E,
symbol: data.s,
markPrice: parseFloat(data.p),
indexPrice: parseFloat(data.i),
estimatedSettlePrice: parseFloat(data.P),
fundingRate: parseFloat(data.r),
nextFundingTime: data.T
};
}
/**
* Convert kline to processed format
*/
function convertKline(data) {
return {
eventType: 'kline',
eventTime: data.E,
symbol: data.s,
kline: {
startTime: data.k.t,
closeTime: data.k.T,
symbol: data.k.s,
interval: data.k.i,
firstTradeId: data.k.f,
lastTradeId: data.k.L,
openPrice: parseFloat(data.k.o),
closePrice: parseFloat(data.k.c),
highPrice: parseFloat(data.k.h),
lowPrice: parseFloat(data.k.l),
baseAssetVolume: parseFloat(data.k.v),
numberOfTrades: data.k.n,
isClosed: data.k.x,
quoteAssetVolume: parseFloat(data.k.q),
takerBuyBaseAssetVolume: parseFloat(data.k.V),
takerBuyQuoteAssetVolume: parseFloat(data.k.Q)
}
};
}
/**
* Convert 24hrTicker to processed format
*/
function convertTicker(data) {
return {
eventType: '24hrTicker',
eventTime: data.E,
symbol: data.s,
priceChange: parseFloat(data.p),
priceChangePercent: parseFloat(data.P),
weightedAvgPrice: parseFloat(data.w),
lastPrice: parseFloat(data.c),
lastQuantity: parseFloat(data.Q),
openPrice: parseFloat(data.o),
highPrice: parseFloat(data.h),
lowPrice: parseFloat(data.l),
totalTradedBaseAssetVolume: parseFloat(data.v),
totalTradedQuoteAssetVolume: parseFloat(data.q),
statisticOpenTime: data.O,
statisticCloseTime: data.C,
firstTradeId: data.F,
lastTradeId: data.L,
totalNumberOfTrades: data.n
};
}
/**
* Convert bookTicker to processed format
*/
function convertBookTicker(data) {
return {
eventType: 'bookTicker',
updateId: data.u,
eventTime: data.E,
transactionTime: data.T,
symbol: data.s,
bestBidPrice: parseFloat(data.b),
bestBidQuantity: parseFloat(data.B),
bestAskPrice: parseFloat(data.a),
bestAskQuantity: parseFloat(data.A)
};
}
/**
* Convert depthUpdate to processed format
*/
function convertPartialBookDepth(data) {
return {
eventType: 'depthUpdate',
eventTime: data.E,
transactionTime: data.T,
symbol: data.s,
firstUpdateId: data.U,
finalUpdateId: data.u,
bids: data.b.map(bid => [parseFloat(bid[0]), parseFloat(bid[1])]),
asks: data.a.map(ask => [parseFloat(ask[0]), parseFloat(ask[1])])
};
}
/**
* Utility function to safely parse float with fallback
*/
function safeParseFloat(value, fallback = 0) {
if (!value)
return fallback;
const parsed = parseFloat(value);
return isNaN(parsed) ? fallback : parsed;
}
/**
* Type guard to check if event is user data event
*/
function isUserDataEvent(event) {
return event && typeof event.e === 'string' &&
['ORDER_TRADE_UPDATE', 'ACCOUNT_UPDATE', 'ACCOUNT_CONFIG_UPDATE', 'MARGIN_CALL'].includes(event.e);
}
/**
* Type guard to check if event is market data event
*/
function isMarketDataEvent(event) {
return event && typeof event.e === 'string' &&
['aggTrade', 'markPriceUpdate', 'kline', '24hrTicker', 'bookTicker', 'depthUpdate'].includes(event.e);
}
//# sourceMappingURL=websocketDataConverter.js.map