@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/CHANGELOG.md +1 -6
- package/dist/generated/openfeed.d.ts +82 -0
- package/dist/generated/openfeed_instrument.d.ts +4 -0
- package/dist/generated/version.d.ts +1 -1
- package/dist/index.js +561 -12
- package/dist/node.js +662 -35
- package/package.json +1 -1
- package/.releases/CHANGELOG-1.1.4.md +0 -26
- package/.releases/CHANGELOG-1.1.5.md +0 -5
- package/.releases/CHANGELOG-1.1.6.md +0 -10
- package/.releases/CHANGELOG-1.2.0.md +0 -10
- package/.releases/CHANGELOG-1.2.1.md +0 -15
- package/.releases/CHANGELOG-1.2.2.md +0 -10
- package/.releases/CHANGELOG-1.2.3.md +0 -10
- package/.releases/CHANGELOG-1.3.0.md +0 -10
- package/.releases/CHANGELOG-1.3.1.md +0 -10
- package/.releases/CHANGELOG-1.3.2.md +0 -10
- package/.releases/CHANGELOG-1.3.3.md +0 -10
- package/.releases/CHANGELOG-1.4.0.md +0 -10
- package/.releases/CHANGELOG-1.4.1.md +0 -15
- package/.releases/CHANGELOG-1.5.0.md +0 -10
- package/.releases/CHANGELOG-1.6.0.md +0 -11
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
|
|
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.
|
|
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
|
|
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
|
|
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
|
-
|
|
3656
|
-
WebSocket2.
|
|
3657
|
-
WebSocket2.
|
|
3658
|
-
WebSocket2.
|
|
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 =
|
|
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 {
|
|
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.
|
|
16269
|
+
var version = "1.7.2";
|
|
15643
16270
|
|
|
15644
16271
|
// src/utilities/client_version.ts
|
|
15645
16272
|
var getClientVersion = async (clientId) => {
|