@waku/discovery 0.0.9-16328a3.0 → 0.0.9-3730abc.0
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/bundle/index.js +776 -53
- package/dist/.tsbuildinfo +1 -1
- package/package.json +1 -1
package/bundle/index.js
CHANGED
|
@@ -15951,7 +15951,7 @@ const duplexPipelineFn = (duplex) => {
|
|
|
15951
15951
|
/* eslint-disable @typescript-eslint/no-namespace */
|
|
15952
15952
|
/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
|
|
15953
15953
|
/* eslint-disable @typescript-eslint/no-empty-interface */
|
|
15954
|
-
var RateLimitProof$
|
|
15954
|
+
var RateLimitProof$6;
|
|
15955
15955
|
(function (RateLimitProof) {
|
|
15956
15956
|
let _codec;
|
|
15957
15957
|
RateLimitProof.codec = () => {
|
|
@@ -16050,8 +16050,8 @@ var RateLimitProof$4;
|
|
|
16050
16050
|
RateLimitProof.decode = (buf, opts) => {
|
|
16051
16051
|
return decodeMessage(buf, RateLimitProof.codec(), opts);
|
|
16052
16052
|
};
|
|
16053
|
-
})(RateLimitProof$
|
|
16054
|
-
var WakuMessage$
|
|
16053
|
+
})(RateLimitProof$6 || (RateLimitProof$6 = {}));
|
|
16054
|
+
var WakuMessage$6;
|
|
16055
16055
|
(function (WakuMessage) {
|
|
16056
16056
|
let _codec;
|
|
16057
16057
|
WakuMessage.codec = () => {
|
|
@@ -16082,7 +16082,7 @@ var WakuMessage$4;
|
|
|
16082
16082
|
}
|
|
16083
16083
|
if (obj.rateLimitProof != null) {
|
|
16084
16084
|
w.uint32(170);
|
|
16085
|
-
RateLimitProof$
|
|
16085
|
+
RateLimitProof$6.codec().encode(obj.rateLimitProof, w);
|
|
16086
16086
|
}
|
|
16087
16087
|
if (obj.ephemeral != null) {
|
|
16088
16088
|
w.uint32(248);
|
|
@@ -16121,7 +16121,7 @@ var WakuMessage$4;
|
|
|
16121
16121
|
break;
|
|
16122
16122
|
}
|
|
16123
16123
|
case 21: {
|
|
16124
|
-
obj.rateLimitProof = RateLimitProof$
|
|
16124
|
+
obj.rateLimitProof = RateLimitProof$6.codec().decode(reader, reader.uint32(), {
|
|
16125
16125
|
limits: opts.limits?.rateLimitProof
|
|
16126
16126
|
});
|
|
16127
16127
|
break;
|
|
@@ -16147,7 +16147,7 @@ var WakuMessage$4;
|
|
|
16147
16147
|
WakuMessage.decode = (buf, opts) => {
|
|
16148
16148
|
return decodeMessage(buf, WakuMessage.codec(), opts);
|
|
16149
16149
|
};
|
|
16150
|
-
})(WakuMessage$
|
|
16150
|
+
})(WakuMessage$6 || (WakuMessage$6 = {}));
|
|
16151
16151
|
|
|
16152
16152
|
/* eslint-disable import/export */
|
|
16153
16153
|
/* eslint-disable complexity */
|
|
@@ -16282,7 +16282,7 @@ var MessagePush$1;
|
|
|
16282
16282
|
if (obj.messages != null) {
|
|
16283
16283
|
for (const value of obj.messages) {
|
|
16284
16284
|
w.uint32(10);
|
|
16285
|
-
WakuMessage$
|
|
16285
|
+
WakuMessage$5.codec().encode(value, w);
|
|
16286
16286
|
}
|
|
16287
16287
|
}
|
|
16288
16288
|
if (opts.lengthDelimited !== false) {
|
|
@@ -16300,7 +16300,7 @@ var MessagePush$1;
|
|
|
16300
16300
|
if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
|
|
16301
16301
|
throw new MaxLengthError('Decode error - map field "messages" had too many elements');
|
|
16302
16302
|
}
|
|
16303
|
-
obj.messages.push(WakuMessage$
|
|
16303
|
+
obj.messages.push(WakuMessage$5.codec().decode(reader, reader.uint32(), {
|
|
16304
16304
|
limits: opts.limits?.messages$
|
|
16305
16305
|
}));
|
|
16306
16306
|
break;
|
|
@@ -16389,7 +16389,7 @@ var FilterRpc;
|
|
|
16389
16389
|
return decodeMessage(buf, FilterRpc.codec(), opts);
|
|
16390
16390
|
};
|
|
16391
16391
|
})(FilterRpc || (FilterRpc = {}));
|
|
16392
|
-
var RateLimitProof$
|
|
16392
|
+
var RateLimitProof$5;
|
|
16393
16393
|
(function (RateLimitProof) {
|
|
16394
16394
|
let _codec;
|
|
16395
16395
|
RateLimitProof.codec = () => {
|
|
@@ -16488,8 +16488,8 @@ var RateLimitProof$3;
|
|
|
16488
16488
|
RateLimitProof.decode = (buf, opts) => {
|
|
16489
16489
|
return decodeMessage(buf, RateLimitProof.codec(), opts);
|
|
16490
16490
|
};
|
|
16491
|
-
})(RateLimitProof$
|
|
16492
|
-
var WakuMessage$
|
|
16491
|
+
})(RateLimitProof$5 || (RateLimitProof$5 = {}));
|
|
16492
|
+
var WakuMessage$5;
|
|
16493
16493
|
(function (WakuMessage) {
|
|
16494
16494
|
let _codec;
|
|
16495
16495
|
WakuMessage.codec = () => {
|
|
@@ -16520,7 +16520,7 @@ var WakuMessage$3;
|
|
|
16520
16520
|
}
|
|
16521
16521
|
if (obj.rateLimitProof != null) {
|
|
16522
16522
|
w.uint32(170);
|
|
16523
|
-
RateLimitProof$
|
|
16523
|
+
RateLimitProof$5.codec().encode(obj.rateLimitProof, w);
|
|
16524
16524
|
}
|
|
16525
16525
|
if (obj.ephemeral != null) {
|
|
16526
16526
|
w.uint32(248);
|
|
@@ -16559,7 +16559,7 @@ var WakuMessage$3;
|
|
|
16559
16559
|
break;
|
|
16560
16560
|
}
|
|
16561
16561
|
case 21: {
|
|
16562
|
-
obj.rateLimitProof = RateLimitProof$
|
|
16562
|
+
obj.rateLimitProof = RateLimitProof$5.codec().decode(reader, reader.uint32(), {
|
|
16563
16563
|
limits: opts.limits?.rateLimitProof
|
|
16564
16564
|
});
|
|
16565
16565
|
break;
|
|
@@ -16585,7 +16585,7 @@ var WakuMessage$3;
|
|
|
16585
16585
|
WakuMessage.decode = (buf, opts) => {
|
|
16586
16586
|
return decodeMessage(buf, WakuMessage.codec(), opts);
|
|
16587
16587
|
};
|
|
16588
|
-
})(WakuMessage$
|
|
16588
|
+
})(WakuMessage$5 || (WakuMessage$5 = {}));
|
|
16589
16589
|
|
|
16590
16590
|
/* eslint-disable import/export */
|
|
16591
16591
|
/* eslint-disable complexity */
|
|
@@ -16814,7 +16814,7 @@ var MessagePush;
|
|
|
16814
16814
|
}
|
|
16815
16815
|
if (obj.wakuMessage != null) {
|
|
16816
16816
|
w.uint32(10);
|
|
16817
|
-
WakuMessage$
|
|
16817
|
+
WakuMessage$4.codec().encode(obj.wakuMessage, w);
|
|
16818
16818
|
}
|
|
16819
16819
|
if (obj.pubsubTopic != null) {
|
|
16820
16820
|
w.uint32(18);
|
|
@@ -16830,7 +16830,7 @@ var MessagePush;
|
|
|
16830
16830
|
const tag = reader.uint32();
|
|
16831
16831
|
switch (tag >>> 3) {
|
|
16832
16832
|
case 1: {
|
|
16833
|
-
obj.wakuMessage = WakuMessage$
|
|
16833
|
+
obj.wakuMessage = WakuMessage$4.codec().decode(reader, reader.uint32(), {
|
|
16834
16834
|
limits: opts.limits?.wakuMessage
|
|
16835
16835
|
});
|
|
16836
16836
|
break;
|
|
@@ -16857,7 +16857,7 @@ var MessagePush;
|
|
|
16857
16857
|
return decodeMessage(buf, MessagePush.codec(), opts);
|
|
16858
16858
|
};
|
|
16859
16859
|
})(MessagePush || (MessagePush = {}));
|
|
16860
|
-
var RateLimitProof$
|
|
16860
|
+
var RateLimitProof$4;
|
|
16861
16861
|
(function (RateLimitProof) {
|
|
16862
16862
|
let _codec;
|
|
16863
16863
|
RateLimitProof.codec = () => {
|
|
@@ -16956,8 +16956,8 @@ var RateLimitProof$2;
|
|
|
16956
16956
|
RateLimitProof.decode = (buf, opts) => {
|
|
16957
16957
|
return decodeMessage(buf, RateLimitProof.codec(), opts);
|
|
16958
16958
|
};
|
|
16959
|
-
})(RateLimitProof$
|
|
16960
|
-
var WakuMessage$
|
|
16959
|
+
})(RateLimitProof$4 || (RateLimitProof$4 = {}));
|
|
16960
|
+
var WakuMessage$4;
|
|
16961
16961
|
(function (WakuMessage) {
|
|
16962
16962
|
let _codec;
|
|
16963
16963
|
WakuMessage.codec = () => {
|
|
@@ -16988,7 +16988,7 @@ var WakuMessage$2;
|
|
|
16988
16988
|
}
|
|
16989
16989
|
if (obj.rateLimitProof != null) {
|
|
16990
16990
|
w.uint32(170);
|
|
16991
|
-
RateLimitProof$
|
|
16991
|
+
RateLimitProof$4.codec().encode(obj.rateLimitProof, w);
|
|
16992
16992
|
}
|
|
16993
16993
|
if (obj.ephemeral != null) {
|
|
16994
16994
|
w.uint32(248);
|
|
@@ -17027,7 +17027,7 @@ var WakuMessage$2;
|
|
|
17027
17027
|
break;
|
|
17028
17028
|
}
|
|
17029
17029
|
case 21: {
|
|
17030
|
-
obj.rateLimitProof = RateLimitProof$
|
|
17030
|
+
obj.rateLimitProof = RateLimitProof$4.codec().decode(reader, reader.uint32(), {
|
|
17031
17031
|
limits: opts.limits?.rateLimitProof
|
|
17032
17032
|
});
|
|
17033
17033
|
break;
|
|
@@ -17053,14 +17053,14 @@ var WakuMessage$2;
|
|
|
17053
17053
|
WakuMessage.decode = (buf, opts) => {
|
|
17054
17054
|
return decodeMessage(buf, WakuMessage.codec(), opts);
|
|
17055
17055
|
};
|
|
17056
|
-
})(WakuMessage$
|
|
17056
|
+
})(WakuMessage$4 || (WakuMessage$4 = {}));
|
|
17057
17057
|
|
|
17058
17058
|
/* eslint-disable import/export */
|
|
17059
17059
|
/* eslint-disable complexity */
|
|
17060
17060
|
/* eslint-disable @typescript-eslint/no-namespace */
|
|
17061
17061
|
/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
|
|
17062
17062
|
/* eslint-disable @typescript-eslint/no-empty-interface */
|
|
17063
|
-
var PushRequest;
|
|
17063
|
+
var PushRequest$1;
|
|
17064
17064
|
(function (PushRequest) {
|
|
17065
17065
|
let _codec;
|
|
17066
17066
|
PushRequest.codec = () => {
|
|
@@ -17069,31 +17069,29 @@ var PushRequest;
|
|
|
17069
17069
|
if (opts.lengthDelimited !== false) {
|
|
17070
17070
|
w.fork();
|
|
17071
17071
|
}
|
|
17072
|
-
if (
|
|
17073
|
-
w.uint32(
|
|
17072
|
+
if (obj.pubsubTopic != null) {
|
|
17073
|
+
w.uint32(162);
|
|
17074
17074
|
w.string(obj.pubsubTopic);
|
|
17075
17075
|
}
|
|
17076
17076
|
if (obj.message != null) {
|
|
17077
|
-
w.uint32(
|
|
17078
|
-
WakuMessage$
|
|
17077
|
+
w.uint32(170);
|
|
17078
|
+
WakuMessage$3.codec().encode(obj.message, w);
|
|
17079
17079
|
}
|
|
17080
17080
|
if (opts.lengthDelimited !== false) {
|
|
17081
17081
|
w.ldelim();
|
|
17082
17082
|
}
|
|
17083
17083
|
}, (reader, length, opts = {}) => {
|
|
17084
|
-
const obj = {
|
|
17085
|
-
pubsubTopic: ''
|
|
17086
|
-
};
|
|
17084
|
+
const obj = {};
|
|
17087
17085
|
const end = length == null ? reader.len : reader.pos + length;
|
|
17088
17086
|
while (reader.pos < end) {
|
|
17089
17087
|
const tag = reader.uint32();
|
|
17090
17088
|
switch (tag >>> 3) {
|
|
17091
|
-
case
|
|
17089
|
+
case 20: {
|
|
17092
17090
|
obj.pubsubTopic = reader.string();
|
|
17093
17091
|
break;
|
|
17094
17092
|
}
|
|
17095
|
-
case
|
|
17096
|
-
obj.message = WakuMessage$
|
|
17093
|
+
case 21: {
|
|
17094
|
+
obj.message = WakuMessage$3.codec().decode(reader, reader.uint32(), {
|
|
17097
17095
|
limits: opts.limits?.message
|
|
17098
17096
|
});
|
|
17099
17097
|
break;
|
|
@@ -17115,8 +17113,8 @@ var PushRequest;
|
|
|
17115
17113
|
PushRequest.decode = (buf, opts) => {
|
|
17116
17114
|
return decodeMessage(buf, PushRequest.codec(), opts);
|
|
17117
17115
|
};
|
|
17118
|
-
})(PushRequest || (PushRequest = {}));
|
|
17119
|
-
var PushResponse;
|
|
17116
|
+
})(PushRequest$1 || (PushRequest$1 = {}));
|
|
17117
|
+
var PushResponse$1;
|
|
17120
17118
|
(function (PushResponse) {
|
|
17121
17119
|
let _codec;
|
|
17122
17120
|
PushResponse.codec = () => {
|
|
@@ -17125,31 +17123,39 @@ var PushResponse;
|
|
|
17125
17123
|
if (opts.lengthDelimited !== false) {
|
|
17126
17124
|
w.fork();
|
|
17127
17125
|
}
|
|
17128
|
-
if ((obj.
|
|
17129
|
-
w.uint32(
|
|
17130
|
-
w.
|
|
17126
|
+
if ((obj.statusCode != null && obj.statusCode !== 0)) {
|
|
17127
|
+
w.uint32(160);
|
|
17128
|
+
w.uint32(obj.statusCode);
|
|
17131
17129
|
}
|
|
17132
|
-
if (obj.
|
|
17133
|
-
w.uint32(
|
|
17134
|
-
w.string(obj.
|
|
17130
|
+
if (obj.statusDesc != null) {
|
|
17131
|
+
w.uint32(242);
|
|
17132
|
+
w.string(obj.statusDesc);
|
|
17133
|
+
}
|
|
17134
|
+
if (obj.relayPeerCount != null) {
|
|
17135
|
+
w.uint32(320);
|
|
17136
|
+
w.uint32(obj.relayPeerCount);
|
|
17135
17137
|
}
|
|
17136
17138
|
if (opts.lengthDelimited !== false) {
|
|
17137
17139
|
w.ldelim();
|
|
17138
17140
|
}
|
|
17139
17141
|
}, (reader, length, opts = {}) => {
|
|
17140
17142
|
const obj = {
|
|
17141
|
-
|
|
17143
|
+
statusCode: 0
|
|
17142
17144
|
};
|
|
17143
17145
|
const end = length == null ? reader.len : reader.pos + length;
|
|
17144
17146
|
while (reader.pos < end) {
|
|
17145
17147
|
const tag = reader.uint32();
|
|
17146
17148
|
switch (tag >>> 3) {
|
|
17147
|
-
case
|
|
17148
|
-
obj.
|
|
17149
|
+
case 20: {
|
|
17150
|
+
obj.statusCode = reader.uint32();
|
|
17149
17151
|
break;
|
|
17150
17152
|
}
|
|
17151
|
-
case
|
|
17152
|
-
obj.
|
|
17153
|
+
case 30: {
|
|
17154
|
+
obj.statusDesc = reader.string();
|
|
17155
|
+
break;
|
|
17156
|
+
}
|
|
17157
|
+
case 40: {
|
|
17158
|
+
obj.relayPeerCount = reader.uint32();
|
|
17153
17159
|
break;
|
|
17154
17160
|
}
|
|
17155
17161
|
default: {
|
|
@@ -17169,8 +17175,8 @@ var PushResponse;
|
|
|
17169
17175
|
PushResponse.decode = (buf, opts) => {
|
|
17170
17176
|
return decodeMessage(buf, PushResponse.codec(), opts);
|
|
17171
17177
|
};
|
|
17172
|
-
})(PushResponse || (PushResponse = {}));
|
|
17173
|
-
var PushRpc;
|
|
17178
|
+
})(PushResponse$1 || (PushResponse$1 = {}));
|
|
17179
|
+
var PushRpc$1;
|
|
17174
17180
|
(function (PushRpc) {
|
|
17175
17181
|
let _codec;
|
|
17176
17182
|
PushRpc.codec = () => {
|
|
@@ -17185,11 +17191,11 @@ var PushRpc;
|
|
|
17185
17191
|
}
|
|
17186
17192
|
if (obj.request != null) {
|
|
17187
17193
|
w.uint32(18);
|
|
17188
|
-
PushRequest.codec().encode(obj.request, w);
|
|
17194
|
+
PushRequest$1.codec().encode(obj.request, w);
|
|
17189
17195
|
}
|
|
17190
17196
|
if (obj.response != null) {
|
|
17191
17197
|
w.uint32(26);
|
|
17192
|
-
PushResponse.codec().encode(obj.response, w);
|
|
17198
|
+
PushResponse$1.codec().encode(obj.response, w);
|
|
17193
17199
|
}
|
|
17194
17200
|
if (opts.lengthDelimited !== false) {
|
|
17195
17201
|
w.ldelim();
|
|
@@ -17207,13 +17213,13 @@ var PushRpc;
|
|
|
17207
17213
|
break;
|
|
17208
17214
|
}
|
|
17209
17215
|
case 2: {
|
|
17210
|
-
obj.request = PushRequest.codec().decode(reader, reader.uint32(), {
|
|
17216
|
+
obj.request = PushRequest$1.codec().decode(reader, reader.uint32(), {
|
|
17211
17217
|
limits: opts.limits?.request
|
|
17212
17218
|
});
|
|
17213
17219
|
break;
|
|
17214
17220
|
}
|
|
17215
17221
|
case 3: {
|
|
17216
|
-
obj.response = PushResponse.codec().decode(reader, reader.uint32(), {
|
|
17222
|
+
obj.response = PushResponse$1.codec().decode(reader, reader.uint32(), {
|
|
17217
17223
|
limits: opts.limits?.response
|
|
17218
17224
|
});
|
|
17219
17225
|
break;
|
|
@@ -17235,7 +17241,724 @@ var PushRpc;
|
|
|
17235
17241
|
PushRpc.decode = (buf, opts) => {
|
|
17236
17242
|
return decodeMessage(buf, PushRpc.codec(), opts);
|
|
17237
17243
|
};
|
|
17238
|
-
})(PushRpc || (PushRpc = {}));
|
|
17244
|
+
})(PushRpc$1 || (PushRpc$1 = {}));
|
|
17245
|
+
var RateLimitProof$3;
|
|
17246
|
+
(function (RateLimitProof) {
|
|
17247
|
+
let _codec;
|
|
17248
|
+
RateLimitProof.codec = () => {
|
|
17249
|
+
if (_codec == null) {
|
|
17250
|
+
_codec = message((obj, w, opts = {}) => {
|
|
17251
|
+
if (opts.lengthDelimited !== false) {
|
|
17252
|
+
w.fork();
|
|
17253
|
+
}
|
|
17254
|
+
if ((obj.proof != null && obj.proof.byteLength > 0)) {
|
|
17255
|
+
w.uint32(10);
|
|
17256
|
+
w.bytes(obj.proof);
|
|
17257
|
+
}
|
|
17258
|
+
if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
|
|
17259
|
+
w.uint32(18);
|
|
17260
|
+
w.bytes(obj.merkleRoot);
|
|
17261
|
+
}
|
|
17262
|
+
if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
|
|
17263
|
+
w.uint32(26);
|
|
17264
|
+
w.bytes(obj.epoch);
|
|
17265
|
+
}
|
|
17266
|
+
if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
|
|
17267
|
+
w.uint32(34);
|
|
17268
|
+
w.bytes(obj.shareX);
|
|
17269
|
+
}
|
|
17270
|
+
if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
|
|
17271
|
+
w.uint32(42);
|
|
17272
|
+
w.bytes(obj.shareY);
|
|
17273
|
+
}
|
|
17274
|
+
if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
|
|
17275
|
+
w.uint32(50);
|
|
17276
|
+
w.bytes(obj.nullifier);
|
|
17277
|
+
}
|
|
17278
|
+
if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
|
|
17279
|
+
w.uint32(58);
|
|
17280
|
+
w.bytes(obj.rlnIdentifier);
|
|
17281
|
+
}
|
|
17282
|
+
if (opts.lengthDelimited !== false) {
|
|
17283
|
+
w.ldelim();
|
|
17284
|
+
}
|
|
17285
|
+
}, (reader, length, opts = {}) => {
|
|
17286
|
+
const obj = {
|
|
17287
|
+
proof: alloc$1(0),
|
|
17288
|
+
merkleRoot: alloc$1(0),
|
|
17289
|
+
epoch: alloc$1(0),
|
|
17290
|
+
shareX: alloc$1(0),
|
|
17291
|
+
shareY: alloc$1(0),
|
|
17292
|
+
nullifier: alloc$1(0),
|
|
17293
|
+
rlnIdentifier: alloc$1(0)
|
|
17294
|
+
};
|
|
17295
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
17296
|
+
while (reader.pos < end) {
|
|
17297
|
+
const tag = reader.uint32();
|
|
17298
|
+
switch (tag >>> 3) {
|
|
17299
|
+
case 1: {
|
|
17300
|
+
obj.proof = reader.bytes();
|
|
17301
|
+
break;
|
|
17302
|
+
}
|
|
17303
|
+
case 2: {
|
|
17304
|
+
obj.merkleRoot = reader.bytes();
|
|
17305
|
+
break;
|
|
17306
|
+
}
|
|
17307
|
+
case 3: {
|
|
17308
|
+
obj.epoch = reader.bytes();
|
|
17309
|
+
break;
|
|
17310
|
+
}
|
|
17311
|
+
case 4: {
|
|
17312
|
+
obj.shareX = reader.bytes();
|
|
17313
|
+
break;
|
|
17314
|
+
}
|
|
17315
|
+
case 5: {
|
|
17316
|
+
obj.shareY = reader.bytes();
|
|
17317
|
+
break;
|
|
17318
|
+
}
|
|
17319
|
+
case 6: {
|
|
17320
|
+
obj.nullifier = reader.bytes();
|
|
17321
|
+
break;
|
|
17322
|
+
}
|
|
17323
|
+
case 7: {
|
|
17324
|
+
obj.rlnIdentifier = reader.bytes();
|
|
17325
|
+
break;
|
|
17326
|
+
}
|
|
17327
|
+
default: {
|
|
17328
|
+
reader.skipType(tag & 7);
|
|
17329
|
+
break;
|
|
17330
|
+
}
|
|
17331
|
+
}
|
|
17332
|
+
}
|
|
17333
|
+
return obj;
|
|
17334
|
+
});
|
|
17335
|
+
}
|
|
17336
|
+
return _codec;
|
|
17337
|
+
};
|
|
17338
|
+
RateLimitProof.encode = (obj) => {
|
|
17339
|
+
return encodeMessage(obj, RateLimitProof.codec());
|
|
17340
|
+
};
|
|
17341
|
+
RateLimitProof.decode = (buf, opts) => {
|
|
17342
|
+
return decodeMessage(buf, RateLimitProof.codec(), opts);
|
|
17343
|
+
};
|
|
17344
|
+
})(RateLimitProof$3 || (RateLimitProof$3 = {}));
|
|
17345
|
+
var WakuMessage$3;
|
|
17346
|
+
(function (WakuMessage) {
|
|
17347
|
+
let _codec;
|
|
17348
|
+
WakuMessage.codec = () => {
|
|
17349
|
+
if (_codec == null) {
|
|
17350
|
+
_codec = message((obj, w, opts = {}) => {
|
|
17351
|
+
if (opts.lengthDelimited !== false) {
|
|
17352
|
+
w.fork();
|
|
17353
|
+
}
|
|
17354
|
+
if ((obj.payload != null && obj.payload.byteLength > 0)) {
|
|
17355
|
+
w.uint32(10);
|
|
17356
|
+
w.bytes(obj.payload);
|
|
17357
|
+
}
|
|
17358
|
+
if ((obj.contentTopic != null && obj.contentTopic !== '')) {
|
|
17359
|
+
w.uint32(18);
|
|
17360
|
+
w.string(obj.contentTopic);
|
|
17361
|
+
}
|
|
17362
|
+
if (obj.version != null) {
|
|
17363
|
+
w.uint32(24);
|
|
17364
|
+
w.uint32(obj.version);
|
|
17365
|
+
}
|
|
17366
|
+
if (obj.timestamp != null) {
|
|
17367
|
+
w.uint32(80);
|
|
17368
|
+
w.sint64(obj.timestamp);
|
|
17369
|
+
}
|
|
17370
|
+
if (obj.meta != null) {
|
|
17371
|
+
w.uint32(90);
|
|
17372
|
+
w.bytes(obj.meta);
|
|
17373
|
+
}
|
|
17374
|
+
if (obj.rateLimitProof != null) {
|
|
17375
|
+
w.uint32(170);
|
|
17376
|
+
RateLimitProof$3.codec().encode(obj.rateLimitProof, w);
|
|
17377
|
+
}
|
|
17378
|
+
if (obj.ephemeral != null) {
|
|
17379
|
+
w.uint32(248);
|
|
17380
|
+
w.bool(obj.ephemeral);
|
|
17381
|
+
}
|
|
17382
|
+
if (opts.lengthDelimited !== false) {
|
|
17383
|
+
w.ldelim();
|
|
17384
|
+
}
|
|
17385
|
+
}, (reader, length, opts = {}) => {
|
|
17386
|
+
const obj = {
|
|
17387
|
+
payload: alloc$1(0),
|
|
17388
|
+
contentTopic: ''
|
|
17389
|
+
};
|
|
17390
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
17391
|
+
while (reader.pos < end) {
|
|
17392
|
+
const tag = reader.uint32();
|
|
17393
|
+
switch (tag >>> 3) {
|
|
17394
|
+
case 1: {
|
|
17395
|
+
obj.payload = reader.bytes();
|
|
17396
|
+
break;
|
|
17397
|
+
}
|
|
17398
|
+
case 2: {
|
|
17399
|
+
obj.contentTopic = reader.string();
|
|
17400
|
+
break;
|
|
17401
|
+
}
|
|
17402
|
+
case 3: {
|
|
17403
|
+
obj.version = reader.uint32();
|
|
17404
|
+
break;
|
|
17405
|
+
}
|
|
17406
|
+
case 10: {
|
|
17407
|
+
obj.timestamp = reader.sint64();
|
|
17408
|
+
break;
|
|
17409
|
+
}
|
|
17410
|
+
case 11: {
|
|
17411
|
+
obj.meta = reader.bytes();
|
|
17412
|
+
break;
|
|
17413
|
+
}
|
|
17414
|
+
case 21: {
|
|
17415
|
+
obj.rateLimitProof = RateLimitProof$3.codec().decode(reader, reader.uint32(), {
|
|
17416
|
+
limits: opts.limits?.rateLimitProof
|
|
17417
|
+
});
|
|
17418
|
+
break;
|
|
17419
|
+
}
|
|
17420
|
+
case 31: {
|
|
17421
|
+
obj.ephemeral = reader.bool();
|
|
17422
|
+
break;
|
|
17423
|
+
}
|
|
17424
|
+
default: {
|
|
17425
|
+
reader.skipType(tag & 7);
|
|
17426
|
+
break;
|
|
17427
|
+
}
|
|
17428
|
+
}
|
|
17429
|
+
}
|
|
17430
|
+
return obj;
|
|
17431
|
+
});
|
|
17432
|
+
}
|
|
17433
|
+
return _codec;
|
|
17434
|
+
};
|
|
17435
|
+
WakuMessage.encode = (obj) => {
|
|
17436
|
+
return encodeMessage(obj, WakuMessage.codec());
|
|
17437
|
+
};
|
|
17438
|
+
WakuMessage.decode = (buf, opts) => {
|
|
17439
|
+
return decodeMessage(buf, WakuMessage.codec(), opts);
|
|
17440
|
+
};
|
|
17441
|
+
})(WakuMessage$3 || (WakuMessage$3 = {}));
|
|
17442
|
+
|
|
17443
|
+
/* eslint-disable import/export */
|
|
17444
|
+
/* eslint-disable complexity */
|
|
17445
|
+
/* eslint-disable @typescript-eslint/no-namespace */
|
|
17446
|
+
/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
|
|
17447
|
+
/* eslint-disable @typescript-eslint/no-empty-interface */
|
|
17448
|
+
var PushRequest;
|
|
17449
|
+
(function (PushRequest) {
|
|
17450
|
+
let _codec;
|
|
17451
|
+
PushRequest.codec = () => {
|
|
17452
|
+
if (_codec == null) {
|
|
17453
|
+
_codec = message((obj, w, opts = {}) => {
|
|
17454
|
+
if (opts.lengthDelimited !== false) {
|
|
17455
|
+
w.fork();
|
|
17456
|
+
}
|
|
17457
|
+
if ((obj.pubsubTopic != null && obj.pubsubTopic !== '')) {
|
|
17458
|
+
w.uint32(10);
|
|
17459
|
+
w.string(obj.pubsubTopic);
|
|
17460
|
+
}
|
|
17461
|
+
if (obj.message != null) {
|
|
17462
|
+
w.uint32(18);
|
|
17463
|
+
WakuMessage$2.codec().encode(obj.message, w);
|
|
17464
|
+
}
|
|
17465
|
+
if (opts.lengthDelimited !== false) {
|
|
17466
|
+
w.ldelim();
|
|
17467
|
+
}
|
|
17468
|
+
}, (reader, length, opts = {}) => {
|
|
17469
|
+
const obj = {
|
|
17470
|
+
pubsubTopic: ''
|
|
17471
|
+
};
|
|
17472
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
17473
|
+
while (reader.pos < end) {
|
|
17474
|
+
const tag = reader.uint32();
|
|
17475
|
+
switch (tag >>> 3) {
|
|
17476
|
+
case 1: {
|
|
17477
|
+
obj.pubsubTopic = reader.string();
|
|
17478
|
+
break;
|
|
17479
|
+
}
|
|
17480
|
+
case 2: {
|
|
17481
|
+
obj.message = WakuMessage$2.codec().decode(reader, reader.uint32(), {
|
|
17482
|
+
limits: opts.limits?.message
|
|
17483
|
+
});
|
|
17484
|
+
break;
|
|
17485
|
+
}
|
|
17486
|
+
default: {
|
|
17487
|
+
reader.skipType(tag & 7);
|
|
17488
|
+
break;
|
|
17489
|
+
}
|
|
17490
|
+
}
|
|
17491
|
+
}
|
|
17492
|
+
return obj;
|
|
17493
|
+
});
|
|
17494
|
+
}
|
|
17495
|
+
return _codec;
|
|
17496
|
+
};
|
|
17497
|
+
PushRequest.encode = (obj) => {
|
|
17498
|
+
return encodeMessage(obj, PushRequest.codec());
|
|
17499
|
+
};
|
|
17500
|
+
PushRequest.decode = (buf, opts) => {
|
|
17501
|
+
return decodeMessage(buf, PushRequest.codec(), opts);
|
|
17502
|
+
};
|
|
17503
|
+
})(PushRequest || (PushRequest = {}));
|
|
17504
|
+
var PushResponse;
|
|
17505
|
+
(function (PushResponse) {
|
|
17506
|
+
let _codec;
|
|
17507
|
+
PushResponse.codec = () => {
|
|
17508
|
+
if (_codec == null) {
|
|
17509
|
+
_codec = message((obj, w, opts = {}) => {
|
|
17510
|
+
if (opts.lengthDelimited !== false) {
|
|
17511
|
+
w.fork();
|
|
17512
|
+
}
|
|
17513
|
+
if ((obj.isSuccess != null && obj.isSuccess !== false)) {
|
|
17514
|
+
w.uint32(8);
|
|
17515
|
+
w.bool(obj.isSuccess);
|
|
17516
|
+
}
|
|
17517
|
+
if (obj.info != null) {
|
|
17518
|
+
w.uint32(18);
|
|
17519
|
+
w.string(obj.info);
|
|
17520
|
+
}
|
|
17521
|
+
if (opts.lengthDelimited !== false) {
|
|
17522
|
+
w.ldelim();
|
|
17523
|
+
}
|
|
17524
|
+
}, (reader, length, opts = {}) => {
|
|
17525
|
+
const obj = {
|
|
17526
|
+
isSuccess: false
|
|
17527
|
+
};
|
|
17528
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
17529
|
+
while (reader.pos < end) {
|
|
17530
|
+
const tag = reader.uint32();
|
|
17531
|
+
switch (tag >>> 3) {
|
|
17532
|
+
case 1: {
|
|
17533
|
+
obj.isSuccess = reader.bool();
|
|
17534
|
+
break;
|
|
17535
|
+
}
|
|
17536
|
+
case 2: {
|
|
17537
|
+
obj.info = reader.string();
|
|
17538
|
+
break;
|
|
17539
|
+
}
|
|
17540
|
+
default: {
|
|
17541
|
+
reader.skipType(tag & 7);
|
|
17542
|
+
break;
|
|
17543
|
+
}
|
|
17544
|
+
}
|
|
17545
|
+
}
|
|
17546
|
+
return obj;
|
|
17547
|
+
});
|
|
17548
|
+
}
|
|
17549
|
+
return _codec;
|
|
17550
|
+
};
|
|
17551
|
+
PushResponse.encode = (obj) => {
|
|
17552
|
+
return encodeMessage(obj, PushResponse.codec());
|
|
17553
|
+
};
|
|
17554
|
+
PushResponse.decode = (buf, opts) => {
|
|
17555
|
+
return decodeMessage(buf, PushResponse.codec(), opts);
|
|
17556
|
+
};
|
|
17557
|
+
})(PushResponse || (PushResponse = {}));
|
|
17558
|
+
var PushRpc;
|
|
17559
|
+
(function (PushRpc) {
|
|
17560
|
+
let _codec;
|
|
17561
|
+
PushRpc.codec = () => {
|
|
17562
|
+
if (_codec == null) {
|
|
17563
|
+
_codec = message((obj, w, opts = {}) => {
|
|
17564
|
+
if (opts.lengthDelimited !== false) {
|
|
17565
|
+
w.fork();
|
|
17566
|
+
}
|
|
17567
|
+
if ((obj.requestId != null && obj.requestId !== '')) {
|
|
17568
|
+
w.uint32(10);
|
|
17569
|
+
w.string(obj.requestId);
|
|
17570
|
+
}
|
|
17571
|
+
if (obj.request != null) {
|
|
17572
|
+
w.uint32(18);
|
|
17573
|
+
PushRequest.codec().encode(obj.request, w);
|
|
17574
|
+
}
|
|
17575
|
+
if (obj.response != null) {
|
|
17576
|
+
w.uint32(26);
|
|
17577
|
+
PushResponse.codec().encode(obj.response, w);
|
|
17578
|
+
}
|
|
17579
|
+
if (opts.lengthDelimited !== false) {
|
|
17580
|
+
w.ldelim();
|
|
17581
|
+
}
|
|
17582
|
+
}, (reader, length, opts = {}) => {
|
|
17583
|
+
const obj = {
|
|
17584
|
+
requestId: ''
|
|
17585
|
+
};
|
|
17586
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
17587
|
+
while (reader.pos < end) {
|
|
17588
|
+
const tag = reader.uint32();
|
|
17589
|
+
switch (tag >>> 3) {
|
|
17590
|
+
case 1: {
|
|
17591
|
+
obj.requestId = reader.string();
|
|
17592
|
+
break;
|
|
17593
|
+
}
|
|
17594
|
+
case 2: {
|
|
17595
|
+
obj.request = PushRequest.codec().decode(reader, reader.uint32(), {
|
|
17596
|
+
limits: opts.limits?.request
|
|
17597
|
+
});
|
|
17598
|
+
break;
|
|
17599
|
+
}
|
|
17600
|
+
case 3: {
|
|
17601
|
+
obj.response = PushResponse.codec().decode(reader, reader.uint32(), {
|
|
17602
|
+
limits: opts.limits?.response
|
|
17603
|
+
});
|
|
17604
|
+
break;
|
|
17605
|
+
}
|
|
17606
|
+
default: {
|
|
17607
|
+
reader.skipType(tag & 7);
|
|
17608
|
+
break;
|
|
17609
|
+
}
|
|
17610
|
+
}
|
|
17611
|
+
}
|
|
17612
|
+
return obj;
|
|
17613
|
+
});
|
|
17614
|
+
}
|
|
17615
|
+
return _codec;
|
|
17616
|
+
};
|
|
17617
|
+
PushRpc.encode = (obj) => {
|
|
17618
|
+
return encodeMessage(obj, PushRpc.codec());
|
|
17619
|
+
};
|
|
17620
|
+
PushRpc.decode = (buf, opts) => {
|
|
17621
|
+
return decodeMessage(buf, PushRpc.codec(), opts);
|
|
17622
|
+
};
|
|
17623
|
+
})(PushRpc || (PushRpc = {}));
|
|
17624
|
+
var RateLimitProof$2;
|
|
17625
|
+
(function (RateLimitProof) {
|
|
17626
|
+
let _codec;
|
|
17627
|
+
RateLimitProof.codec = () => {
|
|
17628
|
+
if (_codec == null) {
|
|
17629
|
+
_codec = message((obj, w, opts = {}) => {
|
|
17630
|
+
if (opts.lengthDelimited !== false) {
|
|
17631
|
+
w.fork();
|
|
17632
|
+
}
|
|
17633
|
+
if ((obj.proof != null && obj.proof.byteLength > 0)) {
|
|
17634
|
+
w.uint32(10);
|
|
17635
|
+
w.bytes(obj.proof);
|
|
17636
|
+
}
|
|
17637
|
+
if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
|
|
17638
|
+
w.uint32(18);
|
|
17639
|
+
w.bytes(obj.merkleRoot);
|
|
17640
|
+
}
|
|
17641
|
+
if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
|
|
17642
|
+
w.uint32(26);
|
|
17643
|
+
w.bytes(obj.epoch);
|
|
17644
|
+
}
|
|
17645
|
+
if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
|
|
17646
|
+
w.uint32(34);
|
|
17647
|
+
w.bytes(obj.shareX);
|
|
17648
|
+
}
|
|
17649
|
+
if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
|
|
17650
|
+
w.uint32(42);
|
|
17651
|
+
w.bytes(obj.shareY);
|
|
17652
|
+
}
|
|
17653
|
+
if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
|
|
17654
|
+
w.uint32(50);
|
|
17655
|
+
w.bytes(obj.nullifier);
|
|
17656
|
+
}
|
|
17657
|
+
if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
|
|
17658
|
+
w.uint32(58);
|
|
17659
|
+
w.bytes(obj.rlnIdentifier);
|
|
17660
|
+
}
|
|
17661
|
+
if (opts.lengthDelimited !== false) {
|
|
17662
|
+
w.ldelim();
|
|
17663
|
+
}
|
|
17664
|
+
}, (reader, length, opts = {}) => {
|
|
17665
|
+
const obj = {
|
|
17666
|
+
proof: alloc$1(0),
|
|
17667
|
+
merkleRoot: alloc$1(0),
|
|
17668
|
+
epoch: alloc$1(0),
|
|
17669
|
+
shareX: alloc$1(0),
|
|
17670
|
+
shareY: alloc$1(0),
|
|
17671
|
+
nullifier: alloc$1(0),
|
|
17672
|
+
rlnIdentifier: alloc$1(0)
|
|
17673
|
+
};
|
|
17674
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
17675
|
+
while (reader.pos < end) {
|
|
17676
|
+
const tag = reader.uint32();
|
|
17677
|
+
switch (tag >>> 3) {
|
|
17678
|
+
case 1: {
|
|
17679
|
+
obj.proof = reader.bytes();
|
|
17680
|
+
break;
|
|
17681
|
+
}
|
|
17682
|
+
case 2: {
|
|
17683
|
+
obj.merkleRoot = reader.bytes();
|
|
17684
|
+
break;
|
|
17685
|
+
}
|
|
17686
|
+
case 3: {
|
|
17687
|
+
obj.epoch = reader.bytes();
|
|
17688
|
+
break;
|
|
17689
|
+
}
|
|
17690
|
+
case 4: {
|
|
17691
|
+
obj.shareX = reader.bytes();
|
|
17692
|
+
break;
|
|
17693
|
+
}
|
|
17694
|
+
case 5: {
|
|
17695
|
+
obj.shareY = reader.bytes();
|
|
17696
|
+
break;
|
|
17697
|
+
}
|
|
17698
|
+
case 6: {
|
|
17699
|
+
obj.nullifier = reader.bytes();
|
|
17700
|
+
break;
|
|
17701
|
+
}
|
|
17702
|
+
case 7: {
|
|
17703
|
+
obj.rlnIdentifier = reader.bytes();
|
|
17704
|
+
break;
|
|
17705
|
+
}
|
|
17706
|
+
default: {
|
|
17707
|
+
reader.skipType(tag & 7);
|
|
17708
|
+
break;
|
|
17709
|
+
}
|
|
17710
|
+
}
|
|
17711
|
+
}
|
|
17712
|
+
return obj;
|
|
17713
|
+
});
|
|
17714
|
+
}
|
|
17715
|
+
return _codec;
|
|
17716
|
+
};
|
|
17717
|
+
RateLimitProof.encode = (obj) => {
|
|
17718
|
+
return encodeMessage(obj, RateLimitProof.codec());
|
|
17719
|
+
};
|
|
17720
|
+
RateLimitProof.decode = (buf, opts) => {
|
|
17721
|
+
return decodeMessage(buf, RateLimitProof.codec(), opts);
|
|
17722
|
+
};
|
|
17723
|
+
})(RateLimitProof$2 || (RateLimitProof$2 = {}));
|
|
17724
|
+
var WakuMessage$2;
|
|
17725
|
+
(function (WakuMessage) {
|
|
17726
|
+
let _codec;
|
|
17727
|
+
WakuMessage.codec = () => {
|
|
17728
|
+
if (_codec == null) {
|
|
17729
|
+
_codec = message((obj, w, opts = {}) => {
|
|
17730
|
+
if (opts.lengthDelimited !== false) {
|
|
17731
|
+
w.fork();
|
|
17732
|
+
}
|
|
17733
|
+
if ((obj.payload != null && obj.payload.byteLength > 0)) {
|
|
17734
|
+
w.uint32(10);
|
|
17735
|
+
w.bytes(obj.payload);
|
|
17736
|
+
}
|
|
17737
|
+
if ((obj.contentTopic != null && obj.contentTopic !== '')) {
|
|
17738
|
+
w.uint32(18);
|
|
17739
|
+
w.string(obj.contentTopic);
|
|
17740
|
+
}
|
|
17741
|
+
if (obj.version != null) {
|
|
17742
|
+
w.uint32(24);
|
|
17743
|
+
w.uint32(obj.version);
|
|
17744
|
+
}
|
|
17745
|
+
if (obj.timestamp != null) {
|
|
17746
|
+
w.uint32(80);
|
|
17747
|
+
w.sint64(obj.timestamp);
|
|
17748
|
+
}
|
|
17749
|
+
if (obj.meta != null) {
|
|
17750
|
+
w.uint32(90);
|
|
17751
|
+
w.bytes(obj.meta);
|
|
17752
|
+
}
|
|
17753
|
+
if (obj.rateLimitProof != null) {
|
|
17754
|
+
w.uint32(170);
|
|
17755
|
+
RateLimitProof$2.codec().encode(obj.rateLimitProof, w);
|
|
17756
|
+
}
|
|
17757
|
+
if (obj.ephemeral != null) {
|
|
17758
|
+
w.uint32(248);
|
|
17759
|
+
w.bool(obj.ephemeral);
|
|
17760
|
+
}
|
|
17761
|
+
if (opts.lengthDelimited !== false) {
|
|
17762
|
+
w.ldelim();
|
|
17763
|
+
}
|
|
17764
|
+
}, (reader, length, opts = {}) => {
|
|
17765
|
+
const obj = {
|
|
17766
|
+
payload: alloc$1(0),
|
|
17767
|
+
contentTopic: ''
|
|
17768
|
+
};
|
|
17769
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
17770
|
+
while (reader.pos < end) {
|
|
17771
|
+
const tag = reader.uint32();
|
|
17772
|
+
switch (tag >>> 3) {
|
|
17773
|
+
case 1: {
|
|
17774
|
+
obj.payload = reader.bytes();
|
|
17775
|
+
break;
|
|
17776
|
+
}
|
|
17777
|
+
case 2: {
|
|
17778
|
+
obj.contentTopic = reader.string();
|
|
17779
|
+
break;
|
|
17780
|
+
}
|
|
17781
|
+
case 3: {
|
|
17782
|
+
obj.version = reader.uint32();
|
|
17783
|
+
break;
|
|
17784
|
+
}
|
|
17785
|
+
case 10: {
|
|
17786
|
+
obj.timestamp = reader.sint64();
|
|
17787
|
+
break;
|
|
17788
|
+
}
|
|
17789
|
+
case 11: {
|
|
17790
|
+
obj.meta = reader.bytes();
|
|
17791
|
+
break;
|
|
17792
|
+
}
|
|
17793
|
+
case 21: {
|
|
17794
|
+
obj.rateLimitProof = RateLimitProof$2.codec().decode(reader, reader.uint32(), {
|
|
17795
|
+
limits: opts.limits?.rateLimitProof
|
|
17796
|
+
});
|
|
17797
|
+
break;
|
|
17798
|
+
}
|
|
17799
|
+
case 31: {
|
|
17800
|
+
obj.ephemeral = reader.bool();
|
|
17801
|
+
break;
|
|
17802
|
+
}
|
|
17803
|
+
default: {
|
|
17804
|
+
reader.skipType(tag & 7);
|
|
17805
|
+
break;
|
|
17806
|
+
}
|
|
17807
|
+
}
|
|
17808
|
+
}
|
|
17809
|
+
return obj;
|
|
17810
|
+
});
|
|
17811
|
+
}
|
|
17812
|
+
return _codec;
|
|
17813
|
+
};
|
|
17814
|
+
WakuMessage.encode = (obj) => {
|
|
17815
|
+
return encodeMessage(obj, WakuMessage.codec());
|
|
17816
|
+
};
|
|
17817
|
+
WakuMessage.decode = (buf, opts) => {
|
|
17818
|
+
return decodeMessage(buf, WakuMessage.codec(), opts);
|
|
17819
|
+
};
|
|
17820
|
+
})(WakuMessage$2 || (WakuMessage$2 = {}));
|
|
17821
|
+
|
|
17822
|
+
/* eslint-disable import/export */
|
|
17823
|
+
/* eslint-disable complexity */
|
|
17824
|
+
/* eslint-disable @typescript-eslint/no-namespace */
|
|
17825
|
+
/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
|
|
17826
|
+
/* eslint-disable @typescript-eslint/no-empty-interface */
|
|
17827
|
+
var LightpushRequest;
|
|
17828
|
+
(function (LightpushRequest) {
|
|
17829
|
+
let _codec;
|
|
17830
|
+
LightpushRequest.codec = () => {
|
|
17831
|
+
if (_codec == null) {
|
|
17832
|
+
_codec = message((obj, w, opts = {}) => {
|
|
17833
|
+
if (opts.lengthDelimited !== false) {
|
|
17834
|
+
w.fork();
|
|
17835
|
+
}
|
|
17836
|
+
if ((obj.requestId != null && obj.requestId !== '')) {
|
|
17837
|
+
w.uint32(10);
|
|
17838
|
+
w.string(obj.requestId);
|
|
17839
|
+
}
|
|
17840
|
+
if (obj.pubsubTopic != null) {
|
|
17841
|
+
w.uint32(162);
|
|
17842
|
+
w.string(obj.pubsubTopic);
|
|
17843
|
+
}
|
|
17844
|
+
if (obj.message != null) {
|
|
17845
|
+
w.uint32(170);
|
|
17846
|
+
WakuMessage$1.codec().encode(obj.message, w);
|
|
17847
|
+
}
|
|
17848
|
+
if (opts.lengthDelimited !== false) {
|
|
17849
|
+
w.ldelim();
|
|
17850
|
+
}
|
|
17851
|
+
}, (reader, length, opts = {}) => {
|
|
17852
|
+
const obj = {
|
|
17853
|
+
requestId: ''
|
|
17854
|
+
};
|
|
17855
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
17856
|
+
while (reader.pos < end) {
|
|
17857
|
+
const tag = reader.uint32();
|
|
17858
|
+
switch (tag >>> 3) {
|
|
17859
|
+
case 1: {
|
|
17860
|
+
obj.requestId = reader.string();
|
|
17861
|
+
break;
|
|
17862
|
+
}
|
|
17863
|
+
case 20: {
|
|
17864
|
+
obj.pubsubTopic = reader.string();
|
|
17865
|
+
break;
|
|
17866
|
+
}
|
|
17867
|
+
case 21: {
|
|
17868
|
+
obj.message = WakuMessage$1.codec().decode(reader, reader.uint32(), {
|
|
17869
|
+
limits: opts.limits?.message
|
|
17870
|
+
});
|
|
17871
|
+
break;
|
|
17872
|
+
}
|
|
17873
|
+
default: {
|
|
17874
|
+
reader.skipType(tag & 7);
|
|
17875
|
+
break;
|
|
17876
|
+
}
|
|
17877
|
+
}
|
|
17878
|
+
}
|
|
17879
|
+
return obj;
|
|
17880
|
+
});
|
|
17881
|
+
}
|
|
17882
|
+
return _codec;
|
|
17883
|
+
};
|
|
17884
|
+
LightpushRequest.encode = (obj) => {
|
|
17885
|
+
return encodeMessage(obj, LightpushRequest.codec());
|
|
17886
|
+
};
|
|
17887
|
+
LightpushRequest.decode = (buf, opts) => {
|
|
17888
|
+
return decodeMessage(buf, LightpushRequest.codec(), opts);
|
|
17889
|
+
};
|
|
17890
|
+
})(LightpushRequest || (LightpushRequest = {}));
|
|
17891
|
+
var LightpushResponse;
|
|
17892
|
+
(function (LightpushResponse) {
|
|
17893
|
+
let _codec;
|
|
17894
|
+
LightpushResponse.codec = () => {
|
|
17895
|
+
if (_codec == null) {
|
|
17896
|
+
_codec = message((obj, w, opts = {}) => {
|
|
17897
|
+
if (opts.lengthDelimited !== false) {
|
|
17898
|
+
w.fork();
|
|
17899
|
+
}
|
|
17900
|
+
if ((obj.requestId != null && obj.requestId !== '')) {
|
|
17901
|
+
w.uint32(10);
|
|
17902
|
+
w.string(obj.requestId);
|
|
17903
|
+
}
|
|
17904
|
+
if ((obj.statusCode != null && obj.statusCode !== 0)) {
|
|
17905
|
+
w.uint32(80);
|
|
17906
|
+
w.uint32(obj.statusCode);
|
|
17907
|
+
}
|
|
17908
|
+
if (obj.statusDesc != null) {
|
|
17909
|
+
w.uint32(90);
|
|
17910
|
+
w.string(obj.statusDesc);
|
|
17911
|
+
}
|
|
17912
|
+
if (obj.relayPeerCount != null) {
|
|
17913
|
+
w.uint32(96);
|
|
17914
|
+
w.uint32(obj.relayPeerCount);
|
|
17915
|
+
}
|
|
17916
|
+
if (opts.lengthDelimited !== false) {
|
|
17917
|
+
w.ldelim();
|
|
17918
|
+
}
|
|
17919
|
+
}, (reader, length, opts = {}) => {
|
|
17920
|
+
const obj = {
|
|
17921
|
+
requestId: '',
|
|
17922
|
+
statusCode: 0
|
|
17923
|
+
};
|
|
17924
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
17925
|
+
while (reader.pos < end) {
|
|
17926
|
+
const tag = reader.uint32();
|
|
17927
|
+
switch (tag >>> 3) {
|
|
17928
|
+
case 1: {
|
|
17929
|
+
obj.requestId = reader.string();
|
|
17930
|
+
break;
|
|
17931
|
+
}
|
|
17932
|
+
case 10: {
|
|
17933
|
+
obj.statusCode = reader.uint32();
|
|
17934
|
+
break;
|
|
17935
|
+
}
|
|
17936
|
+
case 11: {
|
|
17937
|
+
obj.statusDesc = reader.string();
|
|
17938
|
+
break;
|
|
17939
|
+
}
|
|
17940
|
+
case 12: {
|
|
17941
|
+
obj.relayPeerCount = reader.uint32();
|
|
17942
|
+
break;
|
|
17943
|
+
}
|
|
17944
|
+
default: {
|
|
17945
|
+
reader.skipType(tag & 7);
|
|
17946
|
+
break;
|
|
17947
|
+
}
|
|
17948
|
+
}
|
|
17949
|
+
}
|
|
17950
|
+
return obj;
|
|
17951
|
+
});
|
|
17952
|
+
}
|
|
17953
|
+
return _codec;
|
|
17954
|
+
};
|
|
17955
|
+
LightpushResponse.encode = (obj) => {
|
|
17956
|
+
return encodeMessage(obj, LightpushResponse.codec());
|
|
17957
|
+
};
|
|
17958
|
+
LightpushResponse.decode = (buf, opts) => {
|
|
17959
|
+
return decodeMessage(buf, LightpushResponse.codec(), opts);
|
|
17960
|
+
};
|
|
17961
|
+
})(LightpushResponse || (LightpushResponse = {}));
|
|
17239
17962
|
var RateLimitProof$1;
|
|
17240
17963
|
(function (RateLimitProof) {
|
|
17241
17964
|
let _codec;
|