@openfeed/sdk-js 1.6.11 → 1.7.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/node.js CHANGED
@@ -206,6 +206,9 @@ var require_permessage_deflate = __commonJS({
206
206
  * acknowledge disabling of client context takeover
207
207
  * @param {Number} [options.concurrencyLimit=10] The number of concurrent
208
208
  * calls to zlib
209
+ * @param {Boolean} [options.isServer=false] Create the instance in either
210
+ * server or client mode
211
+ * @param {Number} [options.maxPayload=0] The maximum allowed message length
209
212
  * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
210
213
  * use of a custom server window size
211
214
  * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
@@ -216,15 +219,12 @@ var require_permessage_deflate = __commonJS({
216
219
  * deflate
217
220
  * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
218
221
  * inflate
219
- * @param {Boolean} [isServer=false] Create the instance in either server or
220
- * client mode
221
- * @param {Number} [maxPayload=0] The maximum allowed message length
222
222
  */
223
- constructor(options, isServer, maxPayload) {
224
- this._maxPayload = maxPayload | 0;
223
+ constructor(options) {
225
224
  this._options = options || {};
226
225
  this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
227
- this._isServer = !!isServer;
226
+ this._maxPayload = this._options.maxPayload | 0;
227
+ this._isServer = !!this._options.isServer;
228
228
  this._deflate = null;
229
229
  this._inflate = null;
230
230
  this.params = null;
@@ -798,6 +798,10 @@ var require_receiver = __commonJS({
798
798
  * extensions
799
799
  * @param {Boolean} [options.isServer=false] Specifies whether to operate in
800
800
  * client or server mode
801
+ * @param {Number} [options.maxBufferedChunks=0] The maximum number of
802
+ * buffered data chunks
803
+ * @param {Number} [options.maxFragments=0] The maximum number of message
804
+ * fragments
801
805
  * @param {Number} [options.maxPayload=0] The maximum allowed message length
802
806
  * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
803
807
  * not to skip UTF-8 validation for text and close messages
@@ -808,6 +812,8 @@ var require_receiver = __commonJS({
808
812
  this._binaryType = options.binaryType || BINARY_TYPES[0];
809
813
  this._extensions = options.extensions || {};
810
814
  this._isServer = !!options.isServer;
815
+ this._maxBufferedChunks = options.maxBufferedChunks | 0;
816
+ this._maxFragments = options.maxFragments | 0;
811
817
  this._maxPayload = options.maxPayload | 0;
812
818
  this._skipUTF8Validation = !!options.skipUTF8Validation;
813
819
  this[kWebSocket] = void 0;
@@ -837,6 +843,18 @@ var require_receiver = __commonJS({
837
843
  */
838
844
  _write(chunk, encoding, cb) {
839
845
  if (this._opcode === 8 && this._state == GET_INFO) return cb();
846
+ if (this._maxBufferedChunks > 0 && this._buffers.length >= this._maxBufferedChunks) {
847
+ cb(
848
+ this.createError(
849
+ RangeError,
850
+ "Too many buffered chunks",
851
+ false,
852
+ 1008,
853
+ "WS_ERR_TOO_MANY_BUFFERED_PARTS"
854
+ )
855
+ );
856
+ return;
857
+ }
840
858
  this._bufferedBytes += chunk.length;
841
859
  this._buffers.push(chunk);
842
860
  this.startLoop(cb);
@@ -1166,6 +1184,17 @@ var require_receiver = __commonJS({
1166
1184
  return;
1167
1185
  }
1168
1186
  if (data.length) {
1187
+ if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
1188
+ const error = this.createError(
1189
+ RangeError,
1190
+ "Too many message fragments",
1191
+ false,
1192
+ 1008,
1193
+ "WS_ERR_TOO_MANY_BUFFERED_PARTS"
1194
+ );
1195
+ cb(error);
1196
+ return;
1197
+ }
1169
1198
  this._messageLength = this._totalPayloadLength;
1170
1199
  this._fragments.push(data);
1171
1200
  }
@@ -1195,6 +1224,17 @@ var require_receiver = __commonJS({
1195
1224
  cb(error);
1196
1225
  return;
1197
1226
  }
1227
+ if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
1228
+ const error = this.createError(
1229
+ RangeError,
1230
+ "Too many message fragments",
1231
+ false,
1232
+ 1008,
1233
+ "WS_ERR_TOO_MANY_BUFFERED_PARTS"
1234
+ );
1235
+ cb(error);
1236
+ return;
1237
+ }
1198
1238
  this._fragments.push(buf);
1199
1239
  }
1200
1240
  this.dataMessage(cb);
@@ -1361,6 +1401,9 @@ var require_sender = __commonJS({
1361
1401
  "use strict";
1362
1402
  var { Duplex } = __require("stream");
1363
1403
  var { randomFillSync } = __require("crypto");
1404
+ var {
1405
+ types: { isUint8Array }
1406
+ } = __require("util");
1364
1407
  var PerMessageDeflate = require_permessage_deflate();
1365
1408
  var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
1366
1409
  var { isBlob, isValidStatusCode } = require_validation();
@@ -1514,8 +1557,10 @@ var require_sender = __commonJS({
1514
1557
  buf.writeUInt16BE(code, 0);
1515
1558
  if (typeof data === "string") {
1516
1559
  buf.write(data, 2);
1517
- } else {
1560
+ } else if (isUint8Array(data)) {
1518
1561
  buf.set(data, 2);
1562
+ } else {
1563
+ throw new TypeError("Second argument must be a string or a Uint8Array");
1519
1564
  }
1520
1565
  }
1521
1566
  const options = {
@@ -2396,6 +2441,10 @@ var require_websocket = __commonJS({
2396
2441
  * multiple times in the same tick
2397
2442
  * @param {Function} [options.generateMask] The function used to generate the
2398
2443
  * masking key
2444
+ * @param {Number} [options.maxBufferedChunks=0] The maximum number of
2445
+ * buffered data chunks
2446
+ * @param {Number} [options.maxFragments=0] The maximum number of message
2447
+ * fragments
2399
2448
  * @param {Number} [options.maxPayload=0] The maximum allowed message size
2400
2449
  * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
2401
2450
  * not to skip UTF-8 validation for text and close messages
@@ -2407,6 +2456,8 @@ var require_websocket = __commonJS({
2407
2456
  binaryType: this.binaryType,
2408
2457
  extensions: this._extensions,
2409
2458
  isServer: this._isServer,
2459
+ maxBufferedChunks: options.maxBufferedChunks,
2460
+ maxFragments: options.maxFragments,
2410
2461
  maxPayload: options.maxPayload,
2411
2462
  skipUTF8Validation: options.skipUTF8Validation
2412
2463
  });
@@ -2706,6 +2757,8 @@ var require_websocket = __commonJS({
2706
2757
  autoPong: true,
2707
2758
  closeTimeout: CLOSE_TIMEOUT,
2708
2759
  protocolVersion: protocolVersions[1],
2760
+ maxBufferedChunks: 1024 * 1024,
2761
+ maxFragments: 128 * 1024,
2709
2762
  maxPayload: 100 * 1024 * 1024,
2710
2763
  skipUTF8Validation: false,
2711
2764
  perMessageDeflate: true,
@@ -2734,7 +2787,7 @@ var require_websocket = __commonJS({
2734
2787
  } else {
2735
2788
  try {
2736
2789
  parsedUrl = new URL(address);
2737
- } catch (e) {
2790
+ } catch {
2738
2791
  throw new SyntaxError(`Invalid URL: ${address}`);
2739
2792
  }
2740
2793
  }
@@ -2782,11 +2835,11 @@ var require_websocket = __commonJS({
2782
2835
  opts.path = parsedUrl.pathname + parsedUrl.search;
2783
2836
  opts.timeout = opts.handshakeTimeout;
2784
2837
  if (opts.perMessageDeflate) {
2785
- perMessageDeflate = new PerMessageDeflate(
2786
- opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
2787
- false,
2788
- opts.maxPayload
2789
- );
2838
+ perMessageDeflate = new PerMessageDeflate({
2839
+ ...opts.perMessageDeflate,
2840
+ isServer: false,
2841
+ maxPayload: opts.maxPayload
2842
+ });
2790
2843
  opts.headers["Sec-WebSocket-Extensions"] = format({
2791
2844
  [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
2792
2845
  });
@@ -2948,6 +3001,8 @@ var require_websocket = __commonJS({
2948
3001
  websocket.setSocket(socket, head, {
2949
3002
  allowSynchronousEvents: opts.allowSynchronousEvents,
2950
3003
  generateMask: opts.generateMask,
3004
+ maxBufferedChunks: opts.maxBufferedChunks,
3005
+ maxFragments: opts.maxFragments,
2951
3006
  maxPayload: opts.maxPayload,
2952
3007
  skipUTF8Validation: opts.skipUTF8Validation
2953
3008
  });
@@ -3290,6 +3345,10 @@ var require_websocket_server = __commonJS({
3290
3345
  * called
3291
3346
  * @param {Function} [options.handleProtocols] A hook to handle protocols
3292
3347
  * @param {String} [options.host] The hostname where to bind the server
3348
+ * @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
3349
+ * buffered data chunks
3350
+ * @param {Number} [options.maxFragments=131072] The maximum number of message
3351
+ * fragments
3293
3352
  * @param {Number} [options.maxPayload=104857600] The maximum allowed message
3294
3353
  * size
3295
3354
  * @param {Boolean} [options.noServer=false] Enable no server mode
@@ -3311,6 +3370,8 @@ var require_websocket_server = __commonJS({
3311
3370
  options = {
3312
3371
  allowSynchronousEvents: true,
3313
3372
  autoPong: true,
3373
+ maxBufferedChunks: 1024 * 1024,
3374
+ maxFragments: 128 * 1024,
3314
3375
  maxPayload: 100 * 1024 * 1024,
3315
3376
  skipUTF8Validation: false,
3316
3377
  perMessageDeflate: false,
@@ -3497,11 +3558,11 @@ var require_websocket_server = __commonJS({
3497
3558
  const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
3498
3559
  const extensions = {};
3499
3560
  if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
3500
- const perMessageDeflate = new PerMessageDeflate(
3501
- this.options.perMessageDeflate,
3502
- true,
3503
- this.options.maxPayload
3504
- );
3561
+ const perMessageDeflate = new PerMessageDeflate({
3562
+ ...this.options.perMessageDeflate,
3563
+ isServer: true,
3564
+ maxPayload: this.options.maxPayload
3565
+ });
3505
3566
  try {
3506
3567
  const offers = extension.parse(secWebSocketExtensions);
3507
3568
  if (offers[PerMessageDeflate.extensionName]) {
@@ -3590,6 +3651,8 @@ var require_websocket_server = __commonJS({
3590
3651
  socket.removeListener("error", socketOnError);
3591
3652
  ws.setSocket(socket, head, {
3592
3653
  allowSynchronousEvents: this.options.allowSynchronousEvents,
3654
+ maxBufferedChunks: this.options.maxBufferedChunks,
3655
+ maxFragments: this.options.maxFragments,
3593
3656
  maxPayload: this.options.maxPayload,
3594
3657
  skipUTF8Validation: this.options.skipUTF8Validation
3595
3658
  });
@@ -3651,13 +3714,23 @@ var require_websocket_server = __commonJS({
3651
3714
  var require_ws = __commonJS({
3652
3715
  "node_modules/ws/index.js"(exports, module) {
3653
3716
  "use strict";
3717
+ var createWebSocketStream = require_stream();
3718
+ var extension = require_extension();
3719
+ var PerMessageDeflate = require_permessage_deflate();
3720
+ var Receiver = require_receiver();
3721
+ var Sender = require_sender();
3722
+ var subprotocol = require_subprotocol();
3654
3723
  var WebSocket2 = require_websocket();
3655
- WebSocket2.createWebSocketStream = require_stream();
3656
- WebSocket2.Server = require_websocket_server();
3657
- WebSocket2.Receiver = require_receiver();
3658
- WebSocket2.Sender = require_sender();
3724
+ var WebSocketServer = require_websocket_server();
3725
+ WebSocket2.createWebSocketStream = createWebSocketStream;
3726
+ WebSocket2.extension = extension;
3727
+ WebSocket2.PerMessageDeflate = PerMessageDeflate;
3728
+ WebSocket2.Receiver = Receiver;
3729
+ WebSocket2.Sender = Sender;
3730
+ WebSocket2.Server = WebSocketServer;
3731
+ WebSocket2.subprotocol = subprotocol;
3659
3732
  WebSocket2.WebSocket = WebSocket2;
3660
- WebSocket2.WebSocketServer = WebSocket2.Server;
3733
+ WebSocket2.WebSocketServer = WebSocketServer;
3661
3734
  module.exports = WebSocket2;
3662
3735
  }
3663
3736
  });
@@ -5452,7 +5525,9 @@ function createBaseInstrumentDefinition() {
5452
5525
  contractSize: long_default.ZERO,
5453
5526
  contractSizeDescription: "",
5454
5527
  exchangeMetadata: void 0,
5455
- roundLotSize: 0
5528
+ roundLotSize: 0,
5529
+ quantityFractionalDenominator: 0,
5530
+ volumeFractionalDenominator: 0
5456
5531
  };
5457
5532
  }
5458
5533
  var InstrumentDefinitionEncode = {
@@ -5654,6 +5729,12 @@ var InstrumentDefinitionEncode = {
5654
5729
  if (message.roundLotSize !== 0) {
5655
5730
  writer.uint32(1920).sint32(message.roundLotSize);
5656
5731
  }
5732
+ if (message.quantityFractionalDenominator !== 0) {
5733
+ writer.uint32(1928).sint32(message.quantityFractionalDenominator);
5734
+ }
5735
+ if (message.volumeFractionalDenominator !== 0) {
5736
+ writer.uint32(1936).sint32(message.volumeFractionalDenominator);
5737
+ }
5657
5738
  return writer;
5658
5739
  }
5659
5740
  };
@@ -6127,6 +6208,20 @@ var InstrumentDefinitionDecode = {
6127
6208
  message.roundLotSize = reader.sint32();
6128
6209
  continue;
6129
6210
  }
6211
+ case 241: {
6212
+ if (tag !== 1928) {
6213
+ break;
6214
+ }
6215
+ message.quantityFractionalDenominator = reader.sint32();
6216
+ continue;
6217
+ }
6218
+ case 242: {
6219
+ if (tag !== 1936) {
6220
+ break;
6221
+ }
6222
+ message.volumeFractionalDenominator = reader.sint32();
6223
+ continue;
6224
+ }
6130
6225
  }
6131
6226
  if ((tag & 7) === 4 || tag === 0) {
6132
6227
  break;
@@ -6988,7 +7083,10 @@ function createBaseMarketSession() {
6988
7083
  referenceVolatilityPrice: void 0,
6989
7084
  priceLimits: void 0,
6990
7085
  marketOpenInterest: void 0,
6991
- vwap: void 0
7086
+ vwap: void 0,
7087
+ warrantBand: void 0,
7088
+ positionBand: void 0,
7089
+ lastTrade: void 0
6992
7090
  };
6993
7091
  }
6994
7092
  var MarketSessionEncode = {
@@ -7044,6 +7142,15 @@ var MarketSessionEncode = {
7044
7142
  if (message.vwap !== void 0) {
7045
7143
  VwapEncode.encode(message.vwap, writer.uint32(394).fork()).join();
7046
7144
  }
7145
+ if (message.warrantBand !== void 0) {
7146
+ WarrantBandEncode.encode(message.warrantBand, writer.uint32(402).fork()).join();
7147
+ }
7148
+ if (message.positionBand !== void 0) {
7149
+ PositionBandEncode.encode(message.positionBand, writer.uint32(410).fork()).join();
7150
+ }
7151
+ if (message.lastTrade !== void 0) {
7152
+ LastEncode.encode(message.lastTrade, writer.uint32(418).fork()).join();
7153
+ }
7047
7154
  return writer;
7048
7155
  }
7049
7156
  };
@@ -7174,6 +7281,27 @@ var MarketSessionDecode = {
7174
7281
  message.vwap = VwapDecode.decode(reader, reader.uint32());
7175
7282
  continue;
7176
7283
  }
7284
+ case 50: {
7285
+ if (tag !== 402) {
7286
+ break;
7287
+ }
7288
+ message.warrantBand = WarrantBandDecode.decode(reader, reader.uint32());
7289
+ continue;
7290
+ }
7291
+ case 51: {
7292
+ if (tag !== 410) {
7293
+ break;
7294
+ }
7295
+ message.positionBand = PositionBandDecode.decode(reader, reader.uint32());
7296
+ continue;
7297
+ }
7298
+ case 52: {
7299
+ if (tag !== 418) {
7300
+ break;
7301
+ }
7302
+ message.lastTrade = LastDecode.decode(reader, reader.uint32());
7303
+ continue;
7304
+ }
7177
7305
  }
7178
7306
  if ((tag & 7) === 4 || tag === 0) {
7179
7307
  break;
@@ -7228,7 +7356,10 @@ function createBaseMarketSnapshot() {
7228
7356
  priceLimits: void 0,
7229
7357
  sessions: [],
7230
7358
  officialBestBidOffer: void 0,
7231
- marketOpenInterest: void 0
7359
+ marketOpenInterest: void 0,
7360
+ warrantBand: void 0,
7361
+ positionBand: void 0,
7362
+ lastTrade: void 0
7232
7363
  };
7233
7364
  }
7234
7365
  var MarketSnapshotEncode = {
@@ -7365,6 +7496,15 @@ var MarketSnapshotEncode = {
7365
7496
  if (message.marketOpenInterest !== void 0) {
7366
7497
  MarketOpenInterestEncode.encode(message.marketOpenInterest, writer.uint32(466).fork()).join();
7367
7498
  }
7499
+ if (message.warrantBand !== void 0) {
7500
+ WarrantBandEncode.encode(message.warrantBand, writer.uint32(474).fork()).join();
7501
+ }
7502
+ if (message.positionBand !== void 0) {
7503
+ PositionBandEncode.encode(message.positionBand, writer.uint32(482).fork()).join();
7504
+ }
7505
+ if (message.lastTrade !== void 0) {
7506
+ LastEncode.encode(message.lastTrade, writer.uint32(490).fork()).join();
7507
+ }
7368
7508
  return writer;
7369
7509
  }
7370
7510
  };
@@ -7684,6 +7824,27 @@ var MarketSnapshotDecode = {
7684
7824
  message.marketOpenInterest = MarketOpenInterestDecode.decode(reader, reader.uint32());
7685
7825
  continue;
7686
7826
  }
7827
+ case 59: {
7828
+ if (tag !== 474) {
7829
+ break;
7830
+ }
7831
+ message.warrantBand = WarrantBandDecode.decode(reader, reader.uint32());
7832
+ continue;
7833
+ }
7834
+ case 60: {
7835
+ if (tag !== 482) {
7836
+ break;
7837
+ }
7838
+ message.positionBand = PositionBandDecode.decode(reader, reader.uint32());
7839
+ continue;
7840
+ }
7841
+ case 61: {
7842
+ if (tag !== 490) {
7843
+ break;
7844
+ }
7845
+ message.lastTrade = LastDecode.decode(reader, reader.uint32());
7846
+ continue;
7847
+ }
7687
7848
  }
7688
7849
  if ((tag & 7) === 4 || tag === 0) {
7689
7850
  break;
@@ -7742,7 +7903,9 @@ function createBaseMarketUpdate() {
7742
7903
  referenceVolatilityPrice: void 0,
7743
7904
  priceLimits: void 0,
7744
7905
  officialBestBidOffer: void 0,
7745
- marketOpenInterest: void 0
7906
+ marketOpenInterest: void 0,
7907
+ warrantBand: void 0,
7908
+ positionBand: void 0
7746
7909
  };
7747
7910
  }
7748
7911
  var MarketUpdateEncode = {
@@ -7891,6 +8054,12 @@ var MarketUpdateEncode = {
7891
8054
  if (message.marketOpenInterest !== void 0) {
7892
8055
  MarketOpenInterestEncode.encode(message.marketOpenInterest, writer.uint32(426).fork()).join();
7893
8056
  }
8057
+ if (message.warrantBand !== void 0) {
8058
+ WarrantBandEncode.encode(message.warrantBand, writer.uint32(434).fork()).join();
8059
+ }
8060
+ if (message.positionBand !== void 0) {
8061
+ PositionBandEncode.encode(message.positionBand, writer.uint32(442).fork()).join();
8062
+ }
7894
8063
  return writer;
7895
8064
  }
7896
8065
  };
@@ -8238,6 +8407,20 @@ var MarketUpdateDecode = {
8238
8407
  message.marketOpenInterest = MarketOpenInterestDecode.decode(reader, reader.uint32());
8239
8408
  continue;
8240
8409
  }
8410
+ case 54: {
8411
+ if (tag !== 434) {
8412
+ break;
8413
+ }
8414
+ message.warrantBand = WarrantBandDecode.decode(reader, reader.uint32());
8415
+ continue;
8416
+ }
8417
+ case 55: {
8418
+ if (tag !== 442) {
8419
+ break;
8420
+ }
8421
+ message.positionBand = PositionBandDecode.decode(reader, reader.uint32());
8422
+ continue;
8423
+ }
8241
8424
  }
8242
8425
  if ((tag & 7) === 4 || tag === 0) {
8243
8426
  break;
@@ -8675,7 +8858,13 @@ function createBaseBestBidOffer() {
8675
8858
  offerQuoteCondition: new Uint8Array(0),
8676
8859
  quoteCondition: new Uint8Array(0),
8677
8860
  regional: false,
8678
- transient: false
8861
+ transient: false,
8862
+ boloBidParticipantId: new Uint8Array(0),
8863
+ boloBidPrice: long_default.ZERO,
8864
+ boloBidQuantity: long_default.ZERO,
8865
+ boloOfferParticipantId: new Uint8Array(0),
8866
+ boloOfferPrice: long_default.ZERO,
8867
+ boloOfferQuantity: long_default.ZERO
8679
8868
  };
8680
8869
  }
8681
8870
  var BestBidOfferEncode = {
@@ -8722,6 +8911,24 @@ var BestBidOfferEncode = {
8722
8911
  if (message.transient !== false) {
8723
8912
  writer.uint32(264).bool(message.transient);
8724
8913
  }
8914
+ if (message.boloBidParticipantId.length !== 0) {
8915
+ writer.uint32(274).bytes(message.boloBidParticipantId);
8916
+ }
8917
+ if (!message.boloBidPrice.equals(long_default.ZERO)) {
8918
+ writer.uint32(280).sint64(message.boloBidPrice.toString());
8919
+ }
8920
+ if (!message.boloBidQuantity.equals(long_default.ZERO)) {
8921
+ writer.uint32(288).sint64(message.boloBidQuantity.toString());
8922
+ }
8923
+ if (message.boloOfferParticipantId.length !== 0) {
8924
+ writer.uint32(298).bytes(message.boloOfferParticipantId);
8925
+ }
8926
+ if (!message.boloOfferPrice.equals(long_default.ZERO)) {
8927
+ writer.uint32(304).sint64(message.boloOfferPrice.toString());
8928
+ }
8929
+ if (!message.boloOfferQuantity.equals(long_default.ZERO)) {
8930
+ writer.uint32(312).sint64(message.boloOfferQuantity.toString());
8931
+ }
8725
8932
  return writer;
8726
8933
  }
8727
8934
  };
@@ -8831,6 +9038,48 @@ var BestBidOfferDecode = {
8831
9038
  message.transient = reader.bool();
8832
9039
  continue;
8833
9040
  }
9041
+ case 34: {
9042
+ if (tag !== 274) {
9043
+ break;
9044
+ }
9045
+ message.boloBidParticipantId = reader.bytes();
9046
+ continue;
9047
+ }
9048
+ case 35: {
9049
+ if (tag !== 280) {
9050
+ break;
9051
+ }
9052
+ message.boloBidPrice = long_default.fromString(reader.sint64().toString());
9053
+ continue;
9054
+ }
9055
+ case 36: {
9056
+ if (tag !== 288) {
9057
+ break;
9058
+ }
9059
+ message.boloBidQuantity = long_default.fromString(reader.sint64().toString());
9060
+ continue;
9061
+ }
9062
+ case 37: {
9063
+ if (tag !== 298) {
9064
+ break;
9065
+ }
9066
+ message.boloOfferParticipantId = reader.bytes();
9067
+ continue;
9068
+ }
9069
+ case 38: {
9070
+ if (tag !== 304) {
9071
+ break;
9072
+ }
9073
+ message.boloOfferPrice = long_default.fromString(reader.sint64().toString());
9074
+ continue;
9075
+ }
9076
+ case 39: {
9077
+ if (tag !== 312) {
9078
+ break;
9079
+ }
9080
+ message.boloOfferQuantity = long_default.fromString(reader.sint64().toString());
9081
+ continue;
9082
+ }
8834
9083
  }
8835
9084
  if ((tag & 7) === 4 || tag === 0) {
8836
9085
  break;
@@ -9704,7 +9953,8 @@ function createBaseTrade() {
9704
9953
  transactionTime2: long_default.ZERO,
9705
9954
  consolidatedPriceIndicator: "",
9706
9955
  transient: false,
9707
- indexShortName: ""
9956
+ indexShortName: "",
9957
+ quantityFractional: long_default.ZERO
9708
9958
  };
9709
9959
  }
9710
9960
  var TradeEncode = {
@@ -9793,6 +10043,9 @@ var TradeEncode = {
9793
10043
  if (message.indexShortName !== "") {
9794
10044
  writer.uint32(290).string(message.indexShortName);
9795
10045
  }
10046
+ if (!message.quantityFractional.equals(long_default.ZERO)) {
10047
+ writer.uint32(296).sint64(message.quantityFractional.toString());
10048
+ }
9796
10049
  return writer;
9797
10050
  }
9798
10051
  };
@@ -10000,6 +10253,13 @@ var TradeDecode = {
10000
10253
  message.indexShortName = reader.string();
10001
10254
  continue;
10002
10255
  }
10256
+ case 37: {
10257
+ if (tag !== 296) {
10258
+ break;
10259
+ }
10260
+ message.quantityFractional = long_default.fromString(reader.sint64().toString());
10261
+ continue;
10262
+ }
10003
10263
  }
10004
10264
  if ((tag & 7) === 4 || tag === 0) {
10005
10265
  break;
@@ -10033,7 +10293,9 @@ function createBaseTradeCorrection() {
10033
10293
  distributionTime: long_default.ZERO,
10034
10294
  transactionTime2: long_default.ZERO,
10035
10295
  originalTradePrice: long_default.ZERO,
10036
- originalTradeQuantity: long_default.ZERO
10296
+ originalTradeQuantity: long_default.ZERO,
10297
+ quantityFractional: long_default.ZERO,
10298
+ originalQuantityFractional: long_default.ZERO
10037
10299
  };
10038
10300
  }
10039
10301
  var TradeCorrectionEncode = {
@@ -10107,6 +10369,12 @@ var TradeCorrectionEncode = {
10107
10369
  if (!message.originalTradeQuantity.equals(long_default.ZERO)) {
10108
10370
  writer.uint32(240).sint64(message.originalTradeQuantity.toString());
10109
10371
  }
10372
+ if (!message.quantityFractional.equals(long_default.ZERO)) {
10373
+ writer.uint32(248).sint64(message.quantityFractional.toString());
10374
+ }
10375
+ if (!message.originalQuantityFractional.equals(long_default.ZERO)) {
10376
+ writer.uint32(256).sint64(message.originalQuantityFractional.toString());
10377
+ }
10110
10378
  return writer;
10111
10379
  }
10112
10380
  };
@@ -10279,6 +10547,20 @@ var TradeCorrectionDecode = {
10279
10547
  message.originalTradeQuantity = long_default.fromString(reader.sint64().toString());
10280
10548
  continue;
10281
10549
  }
10550
+ case 31: {
10551
+ if (tag !== 248) {
10552
+ break;
10553
+ }
10554
+ message.quantityFractional = long_default.fromString(reader.sint64().toString());
10555
+ continue;
10556
+ }
10557
+ case 32: {
10558
+ if (tag !== 256) {
10559
+ break;
10560
+ }
10561
+ message.originalQuantityFractional = long_default.fromString(reader.sint64().toString());
10562
+ continue;
10563
+ }
10282
10564
  }
10283
10565
  if ((tag & 7) === 4 || tag === 0) {
10284
10566
  break;
@@ -10298,7 +10580,8 @@ function createBaseTradeCancel() {
10298
10580
  saleCondition: new Uint8Array(0),
10299
10581
  currency: "",
10300
10582
  distributionTime: long_default.ZERO,
10301
- transactionTime2: long_default.ZERO
10583
+ transactionTime2: long_default.ZERO,
10584
+ correctedTradeQuantityFractional: long_default.ZERO
10302
10585
  };
10303
10586
  }
10304
10587
  var TradeCancelEncode = {
@@ -10330,6 +10613,9 @@ var TradeCancelEncode = {
10330
10613
  if (!message.transactionTime2.equals(long_default.ZERO)) {
10331
10614
  writer.uint32(128).sint64(message.transactionTime2.toString());
10332
10615
  }
10616
+ if (!message.correctedTradeQuantityFractional.equals(long_default.ZERO)) {
10617
+ writer.uint32(136).sint64(message.correctedTradeQuantityFractional.toString());
10618
+ }
10333
10619
  return writer;
10334
10620
  }
10335
10621
  };
@@ -10404,6 +10690,13 @@ var TradeCancelDecode = {
10404
10690
  message.transactionTime2 = long_default.fromString(reader.sint64().toString());
10405
10691
  continue;
10406
10692
  }
10693
+ case 17: {
10694
+ if (tag !== 136) {
10695
+ break;
10696
+ }
10697
+ message.correctedTradeQuantityFractional = long_default.fromString(reader.sint64().toString());
10698
+ continue;
10699
+ }
10407
10700
  }
10408
10701
  if ((tag & 7) === 4 || tag === 0) {
10409
10702
  break;
@@ -10879,7 +11172,15 @@ var PrevCloseDecode = {
10879
11172
  }
10880
11173
  };
10881
11174
  function createBaseLast() {
10882
- return { transactionTime: long_default.ZERO, tradeDate: 0, price: long_default.ZERO, quantity: long_default.ZERO, currency: "", session: "" };
11175
+ return {
11176
+ transactionTime: long_default.ZERO,
11177
+ tradeDate: 0,
11178
+ price: long_default.ZERO,
11179
+ quantity: long_default.ZERO,
11180
+ currency: "",
11181
+ quantityFractional: long_default.ZERO,
11182
+ session: ""
11183
+ };
10883
11184
  }
10884
11185
  var LastEncode = {
10885
11186
  encode(message, writer = new BinaryWriter()) {
@@ -10898,6 +11199,9 @@ var LastEncode = {
10898
11199
  if (message.currency !== "") {
10899
11200
  writer.uint32(106).string(message.currency);
10900
11201
  }
11202
+ if (!message.quantityFractional.equals(long_default.ZERO)) {
11203
+ writer.uint32(112).sint64(message.quantityFractional.toString());
11204
+ }
10901
11205
  if (message.session !== "") {
10902
11206
  writer.uint32(242).string(message.session);
10903
11207
  }
@@ -10947,6 +11251,13 @@ var LastDecode = {
10947
11251
  message.currency = reader.string();
10948
11252
  continue;
10949
11253
  }
11254
+ case 14: {
11255
+ if (tag !== 112) {
11256
+ break;
11257
+ }
11258
+ message.quantityFractional = long_default.fromString(reader.sint64().toString());
11259
+ continue;
11260
+ }
10950
11261
  case 30: {
10951
11262
  if (tag !== 242) {
10952
11263
  break;
@@ -11074,7 +11385,7 @@ var YearLowDecode = {
11074
11385
  }
11075
11386
  };
11076
11387
  function createBaseVolume() {
11077
- return { transactionTime: long_default.ZERO, tradeDate: 0, volume: long_default.ZERO };
11388
+ return { transactionTime: long_default.ZERO, tradeDate: 0, volume: long_default.ZERO, volumeFractional: long_default.ZERO };
11078
11389
  }
11079
11390
  var VolumeEncode = {
11080
11391
  encode(message, writer = new BinaryWriter()) {
@@ -11087,6 +11398,9 @@ var VolumeEncode = {
11087
11398
  if (!message.volume.equals(long_default.ZERO)) {
11088
11399
  writer.uint32(88).sint64(message.volume.toString());
11089
11400
  }
11401
+ if (!message.volumeFractional.equals(long_default.ZERO)) {
11402
+ writer.uint32(96).sint64(message.volumeFractional.toString());
11403
+ }
11090
11404
  return writer;
11091
11405
  }
11092
11406
  };
@@ -11119,6 +11433,13 @@ var VolumeDecode = {
11119
11433
  message.volume = long_default.fromString(reader.sint64().toString());
11120
11434
  continue;
11121
11435
  }
11436
+ case 12: {
11437
+ if (tag !== 96) {
11438
+ break;
11439
+ }
11440
+ message.volumeFractional = long_default.fromString(reader.sint64().toString());
11441
+ continue;
11442
+ }
11122
11443
  }
11123
11444
  if ((tag & 7) === 4 || tag === 0) {
11124
11445
  break;
@@ -11483,6 +11804,301 @@ var MarketOpenInterestDecode = {
11483
11804
  return message;
11484
11805
  }
11485
11806
  };
11807
+ function createBaseWarrantBand() {
11808
+ return { tradeDate: 0, type: "", productCode: "", bands: [] };
11809
+ }
11810
+ var WarrantBandEncode = {
11811
+ encode(message, writer = new BinaryWriter()) {
11812
+ if (message.tradeDate !== 0) {
11813
+ writer.uint32(8).sint32(message.tradeDate);
11814
+ }
11815
+ if (message.type !== "") {
11816
+ writer.uint32(18).string(message.type);
11817
+ }
11818
+ if (message.productCode !== "") {
11819
+ writer.uint32(26).string(message.productCode);
11820
+ }
11821
+ for (const v of message.bands) {
11822
+ WarrantBandItemEncode.encode(v, writer.uint32(34).fork()).join();
11823
+ }
11824
+ return writer;
11825
+ }
11826
+ };
11827
+ var WarrantBandDecode = {
11828
+ decode(input, length) {
11829
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
11830
+ const end = length === void 0 ? reader.len : reader.pos + length;
11831
+ const message = createBaseWarrantBand();
11832
+ while (reader.pos < end) {
11833
+ const tag = reader.uint32();
11834
+ switch (tag >>> 3) {
11835
+ case 1: {
11836
+ if (tag !== 8) {
11837
+ break;
11838
+ }
11839
+ message.tradeDate = reader.sint32();
11840
+ continue;
11841
+ }
11842
+ case 2: {
11843
+ if (tag !== 18) {
11844
+ break;
11845
+ }
11846
+ message.type = reader.string();
11847
+ continue;
11848
+ }
11849
+ case 3: {
11850
+ if (tag !== 26) {
11851
+ break;
11852
+ }
11853
+ message.productCode = reader.string();
11854
+ continue;
11855
+ }
11856
+ case 4: {
11857
+ if (tag !== 34) {
11858
+ break;
11859
+ }
11860
+ message.bands.push(WarrantBandItemDecode.decode(reader, reader.uint32()));
11861
+ continue;
11862
+ }
11863
+ }
11864
+ if ((tag & 7) === 4 || tag === 0) {
11865
+ break;
11866
+ }
11867
+ reader.skip(tag & 7);
11868
+ }
11869
+ return message;
11870
+ }
11871
+ };
11872
+ function createBaseWarrantBandItem() {
11873
+ return { lowerValue: 0, upperValue: 0, participantCount: 0 };
11874
+ }
11875
+ var WarrantBandItemEncode = {
11876
+ encode(message, writer = new BinaryWriter()) {
11877
+ if (message.lowerValue !== 0) {
11878
+ writer.uint32(8).sint32(message.lowerValue);
11879
+ }
11880
+ if (message.upperValue !== 0) {
11881
+ writer.uint32(16).sint32(message.upperValue);
11882
+ }
11883
+ if (message.participantCount !== 0) {
11884
+ writer.uint32(24).sint32(message.participantCount);
11885
+ }
11886
+ return writer;
11887
+ }
11888
+ };
11889
+ var WarrantBandItemDecode = {
11890
+ decode(input, length) {
11891
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
11892
+ const end = length === void 0 ? reader.len : reader.pos + length;
11893
+ const message = createBaseWarrantBandItem();
11894
+ while (reader.pos < end) {
11895
+ const tag = reader.uint32();
11896
+ switch (tag >>> 3) {
11897
+ case 1: {
11898
+ if (tag !== 8) {
11899
+ break;
11900
+ }
11901
+ message.lowerValue = reader.sint32();
11902
+ continue;
11903
+ }
11904
+ case 2: {
11905
+ if (tag !== 16) {
11906
+ break;
11907
+ }
11908
+ message.upperValue = reader.sint32();
11909
+ continue;
11910
+ }
11911
+ case 3: {
11912
+ if (tag !== 24) {
11913
+ break;
11914
+ }
11915
+ message.participantCount = reader.sint32();
11916
+ continue;
11917
+ }
11918
+ }
11919
+ if ((tag & 7) === 4 || tag === 0) {
11920
+ break;
11921
+ }
11922
+ reader.skip(tag & 7);
11923
+ }
11924
+ return message;
11925
+ }
11926
+ };
11927
+ function createBasePositionBand() {
11928
+ return { tradeDate: 0, productCode: "", shortBands: [], longBands: [] };
11929
+ }
11930
+ var PositionBandEncode = {
11931
+ encode(message, writer = new BinaryWriter()) {
11932
+ if (message.tradeDate !== 0) {
11933
+ writer.uint32(8).sint32(message.tradeDate);
11934
+ }
11935
+ if (message.productCode !== "") {
11936
+ writer.uint32(18).string(message.productCode);
11937
+ }
11938
+ for (const v of message.shortBands) {
11939
+ PositionBandItemEncode.encode(v, writer.uint32(26).fork()).join();
11940
+ }
11941
+ for (const v of message.longBands) {
11942
+ PositionBandItemEncode.encode(v, writer.uint32(34).fork()).join();
11943
+ }
11944
+ return writer;
11945
+ }
11946
+ };
11947
+ var PositionBandDecode = {
11948
+ decode(input, length) {
11949
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
11950
+ const end = length === void 0 ? reader.len : reader.pos + length;
11951
+ const message = createBasePositionBand();
11952
+ while (reader.pos < end) {
11953
+ const tag = reader.uint32();
11954
+ switch (tag >>> 3) {
11955
+ case 1: {
11956
+ if (tag !== 8) {
11957
+ break;
11958
+ }
11959
+ message.tradeDate = reader.sint32();
11960
+ continue;
11961
+ }
11962
+ case 2: {
11963
+ if (tag !== 18) {
11964
+ break;
11965
+ }
11966
+ message.productCode = reader.string();
11967
+ continue;
11968
+ }
11969
+ case 3: {
11970
+ if (tag !== 26) {
11971
+ break;
11972
+ }
11973
+ message.shortBands.push(PositionBandItemDecode.decode(reader, reader.uint32()));
11974
+ continue;
11975
+ }
11976
+ case 4: {
11977
+ if (tag !== 34) {
11978
+ break;
11979
+ }
11980
+ message.longBands.push(PositionBandItemDecode.decode(reader, reader.uint32()));
11981
+ continue;
11982
+ }
11983
+ }
11984
+ if ((tag & 7) === 4 || tag === 0) {
11985
+ break;
11986
+ }
11987
+ reader.skip(tag & 7);
11988
+ }
11989
+ return message;
11990
+ }
11991
+ };
11992
+ function createBasePositionBandItem() {
11993
+ return { positionLowerValue: 0, positionUpperValue: 0, promptCounts: [] };
11994
+ }
11995
+ var PositionBandItemEncode = {
11996
+ encode(message, writer = new BinaryWriter()) {
11997
+ if (message.positionLowerValue !== 0) {
11998
+ writer.uint32(8).sint32(message.positionLowerValue);
11999
+ }
12000
+ if (message.positionUpperValue !== 0) {
12001
+ writer.uint32(16).sint32(message.positionUpperValue);
12002
+ }
12003
+ for (const v of message.promptCounts) {
12004
+ PromptCountEncode.encode(v, writer.uint32(26).fork()).join();
12005
+ }
12006
+ return writer;
12007
+ }
12008
+ };
12009
+ var PositionBandItemDecode = {
12010
+ decode(input, length) {
12011
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
12012
+ const end = length === void 0 ? reader.len : reader.pos + length;
12013
+ const message = createBasePositionBandItem();
12014
+ while (reader.pos < end) {
12015
+ const tag = reader.uint32();
12016
+ switch (tag >>> 3) {
12017
+ case 1: {
12018
+ if (tag !== 8) {
12019
+ break;
12020
+ }
12021
+ message.positionLowerValue = reader.sint32();
12022
+ continue;
12023
+ }
12024
+ case 2: {
12025
+ if (tag !== 16) {
12026
+ break;
12027
+ }
12028
+ message.positionUpperValue = reader.sint32();
12029
+ continue;
12030
+ }
12031
+ case 3: {
12032
+ if (tag !== 26) {
12033
+ break;
12034
+ }
12035
+ message.promptCounts.push(PromptCountDecode.decode(reader, reader.uint32()));
12036
+ continue;
12037
+ }
12038
+ }
12039
+ if ((tag & 7) === 4 || tag === 0) {
12040
+ break;
12041
+ }
12042
+ reader.skip(tag & 7);
12043
+ }
12044
+ return message;
12045
+ }
12046
+ };
12047
+ function createBasePromptCount() {
12048
+ return { promptDateLabel: "", expiryDate: 0, participantCount: 0 };
12049
+ }
12050
+ var PromptCountEncode = {
12051
+ encode(message, writer = new BinaryWriter()) {
12052
+ if (message.promptDateLabel !== "") {
12053
+ writer.uint32(10).string(message.promptDateLabel);
12054
+ }
12055
+ if (message.expiryDate !== 0) {
12056
+ writer.uint32(16).sint32(message.expiryDate);
12057
+ }
12058
+ if (message.participantCount !== 0) {
12059
+ writer.uint32(24).sint32(message.participantCount);
12060
+ }
12061
+ return writer;
12062
+ }
12063
+ };
12064
+ var PromptCountDecode = {
12065
+ decode(input, length) {
12066
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
12067
+ const end = length === void 0 ? reader.len : reader.pos + length;
12068
+ const message = createBasePromptCount();
12069
+ while (reader.pos < end) {
12070
+ const tag = reader.uint32();
12071
+ switch (tag >>> 3) {
12072
+ case 1: {
12073
+ if (tag !== 10) {
12074
+ break;
12075
+ }
12076
+ message.promptDateLabel = reader.string();
12077
+ continue;
12078
+ }
12079
+ case 2: {
12080
+ if (tag !== 16) {
12081
+ break;
12082
+ }
12083
+ message.expiryDate = reader.sint32();
12084
+ continue;
12085
+ }
12086
+ case 3: {
12087
+ if (tag !== 24) {
12088
+ break;
12089
+ }
12090
+ message.participantCount = reader.sint32();
12091
+ continue;
12092
+ }
12093
+ }
12094
+ if ((tag & 7) === 4 || tag === 0) {
12095
+ break;
12096
+ }
12097
+ reader.skip(tag & 7);
12098
+ }
12099
+ return message;
12100
+ }
12101
+ };
11486
12102
  function createBaseVwap() {
11487
12103
  return { transactionTime: long_default.ZERO, tradeDate: 0, vwap: long_default.ZERO };
11488
12104
  }
@@ -12193,7 +12809,8 @@ function createBaseMarketSummary() {
12193
12809
  session: "",
12194
12810
  summaryType: 0,
12195
12811
  prevVolume: void 0,
12196
- transient: false
12812
+ transient: false,
12813
+ lastTrade: void 0
12197
12814
  };
12198
12815
  }
12199
12816
  var MarketSummaryEncode = {
@@ -12261,6 +12878,9 @@ var MarketSummaryEncode = {
12261
12878
  if (message.transient !== false) {
12262
12879
  writer.uint32(192).bool(message.transient);
12263
12880
  }
12881
+ if (message.lastTrade !== void 0) {
12882
+ LastEncode.encode(message.lastTrade, writer.uint32(202).fork()).join();
12883
+ }
12264
12884
  return writer;
12265
12885
  }
12266
12886
  };
@@ -12419,6 +13039,13 @@ var MarketSummaryDecode = {
12419
13039
  message.transient = reader.bool();
12420
13040
  continue;
12421
13041
  }
13042
+ case 25: {
13043
+ if (tag !== 202) {
13044
+ break;
13045
+ }
13046
+ message.lastTrade = LastDecode.decode(reader, reader.uint32());
13047
+ continue;
13048
+ }
12422
13049
  }
12423
13050
  if ((tag & 7) === 4 || tag === 0) {
12424
13051
  break;
@@ -15639,7 +16266,7 @@ var OpenFeedConnection = class {
15639
16266
  };
15640
16267
 
15641
16268
  // generated/version.ts
15642
- var version = "1.6.11";
16269
+ var version = "1.7.2";
15643
16270
 
15644
16271
  // src/utilities/client_version.ts
15645
16272
  var getClientVersion = async (clientId) => {