Adding combined streams, parseFloats

index.ts

@@ -46,5 +46,6 @@ export { Ticker } from "./src/models/ticker/Ticker";
 export { TickerStatistics } from "./src/models/ticker/TickerStatistics";
 export { Trade } from "./src/models/trade/Trade";
 export { TradeUpdate } from "./src/models/websocket/trade/TradeUpdate";
+export { RawTradeUpdate } from "./src/models/websocket/trade/RawTradeUpdate";
 
 export { BinanceApiClient } from "./src/BinanceApiClient";

src/BinanceApiClient.ts

@@ -26,6 +26,7 @@ import * as WebSocket from "ws";
 import { OrderBookUpdate } from "./models/websocket/depth/OrderBookUpdate";
 import { CandlestickUpdate } from "./models/websocket/candlestick/CandlestickUpdate";
 import { TradeUpdate } from "./models/websocket/trade/TradeUpdate";
+import { RawTradeUpdate } from "./models/websocket/trade/RawTradeUpdate";
 import { AccountUpdate } from "./models/websocket/account/AccountUpdate";
 import { OrderUpdate } from "./models/websocket/order/OrderUpdate";
 import { ExchangeInfo } from "./models/misc/ExchangeInfo";
@@ -39,6 +40,7 @@ import { HeartbeatHandler } from "websocket-heartbeats";
  */
 export class BinanceApiClient {
 
+    private static readonly COMBINED_WS_BASE_URL: string = "wss://stream.binance.com:9443/stream?streams=";
     private static readonly WS_BASE_URL: string = "wss://stream.binance.com:9443/ws/";
     private static readonly DEFAULT_WS_TIMEOUT: number = 60000;
 
@@ -257,6 +259,9 @@ export class BinanceApiClient {
         icebergQuantity?: number,
         responseType?: ResponseType ): Promise< OrderAcknowledgement | OrderResult | OrderFull > {
 
+
+        const priceAsString: string = price.toFixed(8);
+        console.log("BinanceApiClient says the price is" + priceAsString);
         let jsonResponse: any = await this.makeRequest(
             HttpMethod.POST,
             ApiVersion.V3,
@@ -272,7 +277,7 @@ export class BinanceApiClient {
             [ "quantity", quantity ],
             [
                 "price",
-                type === OrderType.MARKET || type === OrderType.STOP_LOSS ? null : price
+                (type === OrderType.MARKET || type === OrderType.STOP_LOSS) ? null : priceAsString
             ],
             [ "newClientOrderId", clientOrderId ],
             [ "stopPrice", stopPrice ],
@@ -587,6 +592,49 @@ export class BinanceApiClient {
 
     }
 
+    /**
+     * Initializes a web socket data stream that gives us information about a combined
+     * stream of an array of symbol's order book updates.
+     *
+     * @param symbols           The symbols of which we want to get the order book updates.
+     * @param onUpdate          A function to be called when a new update is received.
+     * @param connectionTimeout Timeout based on which the web socket connection is
+     *                          considered to be broken based on a heartbeat monitor.
+     * @param onLostConnection  A callback to be invoked when the web socket connection
+     *                          is detected as broken.
+     */
+     public monitorOrderBookCombined(
+        symbol: string[],
+        onUpdate: ( update: OrderBookUpdate ) => any,
+        connectionTimeout: number,
+        onLostConnection: () => any ): void {
+
+        let url: string = "";
+        url = BinanceApiClient.COMBINED_WS_BASE_URL;
+        for ( let s of symbol ) {
+            url += s.toLowerCase() + "@depth" + "/";
+        }
+        // Trim the final slash
+        url.slice( 0, -1 );
+        const websocket: WebSocket = new WebSocket(
+            url,
+            { perMessageDeflate: false }
+        );
+
+        new HeartbeatHandler(
+            websocket,
+            isNullOrUndefined( connectionTimeout ) ? BinanceApiClient.DEFAULT_WS_TIMEOUT : connectionTimeout,
+            onLostConnection
+        ).handle();
+
+        websocket.on( "message", ( data: any ) => {
+            // For a combined stream the data is wrapped in an object with the
+            // streamname and the raw data.
+            const rawData = JSON.parse( data );
+            onUpdate( new OrderBookUpdate( rawData.data ) );
+        } );
+
+    }
     /**
      * Initializes a web socket data stream that gives us information about a
      * single symbol's order book updates. Stream keepalive is performed through
@@ -625,6 +673,50 @@ export class BinanceApiClient {
 
     /**
      * Initializes a web socket data stream that gives us information about
+     * Kline/candlestick updates for a number of symbols on the one socket.
+     *
+     * @param symbols           The symbols of which we want to get the candlestick updates.
+     * @param interval          The interval to which the requested candlestick updates
+     *                          refer to.
+     * @param onUpdate          A function to be called when a new update is received.
+     * @param connectionTimeout Timeout based on which the web socket connection is
+     *                          considered to be broken based on a heartbeat monitor.
+     * @param onLostConnection  A callback to be invoked when the web socket connection
+     *                          is detected as broken.
+     */
+     public async monitorCandlesticksCombined(
+         symbols: string[],
+         interval: CandlestickInterval,
+         onUpdate: ( update: CandlestickUpdate ) => any,
+         connectionTimeout?: number,
+         onLostConnection?: () => any ): Promise< void > {
+
+         let url: string = "";
+         url = BinanceApiClient.COMBINED_WS_BASE_URL;
+         for ( let s of symbols ) {
+             url += s.toLowerCase() + "@kline_" + interval + "/";
+         }
+         // Trim the final slash
+         url.slice( 0, -1 );
+         const websocket: WebSocket = new WebSocket(
+             url,
+             { perMessageDeflate: false }
+         );
+
+         new HeartbeatHandler(
+             websocket,
+             isNullOrUndefined( connectionTimeout ) ? BinanceApiClient.DEFAULT_WS_TIMEOUT : connectionTimeout,
+             onLostConnection
+         ).handle();
+
+         websocket.on( "message", ( data: any ) => {
+             const rawData = JSON.parse( data );
+             onUpdate( new CandlestickUpdate( rawData.data ) );
+         } );
+
+    }
+
+    /**
      * Kline/candlestick updates. Stream keepalive is performed through
      * [[keepAliveUserStream]] following the rules described
      * [here](https://github.com/binance-exchange/binance-official-api-docs/blob/master/web-socket-streams.md)
@@ -662,6 +754,89 @@ export class BinanceApiClient {
 
     }
 
+
+    /**
+     * Initializes a web socket data stream that gives us information about
+     * trade updates for a number of symbols on the one socket.
+     *
+     * @param symbols           The symbols of which we want to get the trade updates.
+     * @param onUpdate          A function to be called when a new update is received.
+     * @param connectionTimeout Timeout based on which the web socket connection is
+     *                          considered to be broken based on a heartbeat monitor.
+     * @param onLostConnection  A callback to be invoked when the web socket connection
+     *                          is detected as broken.
+     */
+    public monitorRawTradesCombined(
+         symbols: string[],
+         onUpdate: ( update: RawTradeUpdate ) => any,
+         connectionTimeout: number,
+         onLostConnection: () => any ): void {
+         let url: string = "";
+         url = BinanceApiClient.COMBINED_WS_BASE_URL;
+         for ( let s of symbols ) {
+             url += s.toLowerCase() + "@trade" + "/";
+         }
+         // Trim the final slash
+         url.slice( 0, -1 );
+         const websocket: WebSocket = new WebSocket(
+             url,
+             { perMessageDeflate: false }
+         );
+
+         new HeartbeatHandler(
+             websocket,
+             isNullOrUndefined( connectionTimeout ) ? BinanceApiClient.DEFAULT_WS_TIMEOUT : connectionTimeout,
+             onLostConnection
+         ).handle();
+
+         websocket.on( "message", ( data: any ) => {
+             const rawData = JSON.parse( data );
+             onUpdate( new RawTradeUpdate( rawData.data ) );
+         } );
+
+     }
+
+     /**
+      * Initializes a web socket data stream that gives us information about
+      * trade updates for a number of symbols on the one socket.
+      *
+      * @param symbols           The symbols of which we want to get the trade updates.
+      * @param onUpdate          A function to be called when a new update is received.
+      * @param connectionTimeout Timeout based on which the web socket connection is
+      *                          considered to be broken based on a heartbeat monitor.
+      * @param onLostConnection  A callback to be invoked when the web socket connection
+      *                          is detected as broken.
+      */
+     public monitorTradesCombined(
+          symbols: string[],
+          onUpdate: ( update: TradeUpdate ) => any,
+          connectionTimeout: number,
+          onLostConnection: () => any ): void {
+          let url: string = "";
+          url = BinanceApiClient.COMBINED_WS_BASE_URL;
+          for ( let s of symbols ) {
+              url += s.toLowerCase() + "@aggTrade" + "/";
+          }
+          // Trim the final slash
+          url.slice( 0, -1 );
+          const websocket: WebSocket = new WebSocket(
+              url,
+              { perMessageDeflate: false }
+          );
+
+          new HeartbeatHandler(
+              websocket,
+              isNullOrUndefined( connectionTimeout ) ? BinanceApiClient.DEFAULT_WS_TIMEOUT : connectionTimeout,
+              onLostConnection
+          ).handle();
+
+          websocket.on( "message", ( data: any ) => {
+              const rawData = JSON.parse( data );
+              onUpdate( new TradeUpdate( rawData.data ) );
+          } );
+
+    }
+
     /**
      * Initializes a web socket data stream that gives us information about
      * trade updates. Stream keepalive is performed through
@@ -790,7 +965,7 @@ export class BinanceApiClient {
             this.setupAuthentication( httpMethod, apiUrl, requiredAuthentication );
 
         try {
-
+            
             return await request( {
 
                 method: HttpMethod[ httpMethod ],

src/models/account/Balance.ts

@@ -11,8 +11,8 @@ export class Balance {
     constructor( json: any ) {
 
         this._asset = json.asset || json.a;
-        this._available = json.free || json.available || json.f;
-        this._locked = json.locked || json.l;
+        this._available = parseFloat(json.free || json.available || json.f);
+        this._locked = parseFloat(json.locked || json.l);
 
     }
 

src/models/candlestick/Candlestick.ts

@@ -18,16 +18,16 @@ export class Candlestick {
     constructor( json: any ) {
 
         this._openingTime = new Date( json[ 0 ] );
-        this._openingPrice = json[ 1 ];
-        this._highestPrice = json[ 2 ];
-        this._lowestPrice = json[ 3 ];
-        this._closurePrice = json[ 4 ];
-        this._baseAssetVolume = json[ 5 ];
+        this._openingPrice = parseFloat(json[ 1 ]);
+        this._highestPrice = parseFloat(json[ 2 ]);
+        this._lowestPrice = parseFloat(json[ 3 ]);
+        this._closurePrice = parseFloat(json[ 4 ]);
+        this._baseAssetVolume = parseFloat(json[ 5 ]);
         this._closureTime = new Date( json[ 6 ] );
-        this._quoteAssetVolume = json[ 7 ];
+        this._quoteAssetVolume = parseFloat(json[ 7 ]);
         this._tradesCount = json[ 8 ];
-        this._boughtBaseAssetVolume = json[ 9 ];
-        this._boughtQuoteAssetVolume = json[ 10 ];
+        this._boughtBaseAssetVolume = parseFloat(json[ 9 ]);
+        this._boughtQuoteAssetVolume = parseFloat(json[ 10 ]);
 
     }
 

src/models/depth/LatestPrice.ts

@@ -8,7 +8,7 @@ export class LatestPrice {
 
     constructor( json: any ) {
         this._symbol = json.symbol;
-        this._price = json.price;
+        this._price = parseFloat(json.price);
     }
 
     get symbol(): string {

src/models/filter/LotSizeFilter.ts

@@ -11,9 +11,9 @@ export class LotSizeFilter implements SymbolFilter {
 
     constructor( json: any ) {
 
-        this._minimumQuantity = json.minQty;
-        this._maximumQuantity = json.maxQty;
-        this._stepSize = json.stepSize;
+        this._minimumQuantity = parseFloat(json.minQty);
+        this._maximumQuantity = parseFloat(json.maxQty);
+        this._stepSize = parseFloat(json.stepSize);
 
     }
 

src/models/filter/MinimumNotionalFilter.ts

@@ -8,7 +8,7 @@ export class MinimumNotionalFilter implements SymbolFilter {
     private _value: number;
 
     constructor( json: any ) {
-        this._value = json.minNotional;
+        this._value = parseFloat(json.minNotional);
     }
 
     get value(): number {

src/models/filter/PriceFilter.ts

@@ -11,9 +11,9 @@ export class PriceFilter implements SymbolFilter {
 
     constructor( json: any ) {
 
-        this._minimumPrice = json.minPrice;
-        this._maximumPrice = json.maxPrice;
-        this._tickSize = json.tickSize;
+        this._minimumPrice = parseFloat(json.minPrice);
+        this._maximumPrice = parseFloat(json.maxPrice);
+        this._tickSize = parseFloat(json.tickSize);
 
     }
 

src/models/order/Order.ts

@@ -28,15 +28,15 @@ export class Order {
         this._symbol = json.symbol;
         this._id = json.orderId;
         this._clientId = json.clientOrderId;
-        this._price = json.price;
-        this._originalQuantity = json.origQty;
-        this._executedQuantity = json.executedQty;
+        this._price = parseFloat(json.price);
+        this._originalQuantity = parseFloat(json.origQty);
+        this._executedQuantity = parseFloat(json.executedQty);
         this._status = OrderStatus[ json.status as keyof typeof OrderStatus ];
         this._timeInForce = TimeInForce[ json.timeInForce as keyof typeof TimeInForce ];
         this._type = OrderType[ json.type as keyof typeof OrderType ];
         this._side = OrderSide[ json.side as keyof typeof OrderSide ];
-        this._stopPrice = json.stopPrice;
-        this._icebergQuantity = json.icebergQty;
+        this._stopPrice = parseFloat(json.stopPrice);
+        this._icebergQuantity = parseFloat(json.icebergQty);
         this._timestamp = new Date( json.time );
 
     }