@libp2p/daemon-protocol 8.0.3 → 8.0.4
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/README.md +1 -1
- package/dist/index.min.js +1 -1
- package/dist/index.min.js.map +4 -4
- package/dist/src/index.d.ts +455 -37
- package/dist/src/index.d.ts.map +1 -1
- package/dist/src/index.js +1220 -243
- package/dist/src/index.js.map +1 -1
- package/dist/typedoc-urls.json +190 -0
- package/package.json +6 -5
- package/src/index.ts +1737 -196
package/dist/src/index.js
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { decodeMessage, encodeMessage, enumeration, MaxLengthError, message, streamMessage } from 'protons-runtime';
|
|
2
|
+
import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc';
|
|
2
3
|
export var Request;
|
|
3
4
|
(function (Request) {
|
|
4
5
|
let Type;
|
|
@@ -78,55 +79,153 @@ export var Request;
|
|
|
78
79
|
if (opts.lengthDelimited !== false) {
|
|
79
80
|
w.ldelim();
|
|
80
81
|
}
|
|
81
|
-
}, (reader, length) => {
|
|
82
|
+
}, (reader, length, opts = {}) => {
|
|
82
83
|
const obj = {};
|
|
83
84
|
const end = length == null ? reader.len : reader.pos + length;
|
|
84
85
|
while (reader.pos < end) {
|
|
85
86
|
const tag = reader.uint32();
|
|
86
87
|
switch (tag >>> 3) {
|
|
87
|
-
case 1:
|
|
88
|
+
case 1: {
|
|
88
89
|
obj.type = Request.Type.codec().decode(reader);
|
|
89
90
|
break;
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
break;
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
break;
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
break;
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
break;
|
|
114
|
-
|
|
91
|
+
}
|
|
92
|
+
case 2: {
|
|
93
|
+
obj.connect = ConnectRequest.codec().decode(reader, reader.uint32(), {
|
|
94
|
+
limits: opts.limits?.connect
|
|
95
|
+
});
|
|
96
|
+
break;
|
|
97
|
+
}
|
|
98
|
+
case 3: {
|
|
99
|
+
obj.streamOpen = StreamOpenRequest.codec().decode(reader, reader.uint32(), {
|
|
100
|
+
limits: opts.limits?.streamOpen
|
|
101
|
+
});
|
|
102
|
+
break;
|
|
103
|
+
}
|
|
104
|
+
case 4: {
|
|
105
|
+
obj.streamHandler = StreamHandlerRequest.codec().decode(reader, reader.uint32(), {
|
|
106
|
+
limits: opts.limits?.streamHandler
|
|
107
|
+
});
|
|
108
|
+
break;
|
|
109
|
+
}
|
|
110
|
+
case 5: {
|
|
111
|
+
obj.dht = DHTRequest.codec().decode(reader, reader.uint32(), {
|
|
112
|
+
limits: opts.limits?.dht
|
|
113
|
+
});
|
|
114
|
+
break;
|
|
115
|
+
}
|
|
116
|
+
case 6: {
|
|
117
|
+
obj.connManager = ConnManagerRequest.codec().decode(reader, reader.uint32(), {
|
|
118
|
+
limits: opts.limits?.connManager
|
|
119
|
+
});
|
|
120
|
+
break;
|
|
121
|
+
}
|
|
122
|
+
case 7: {
|
|
123
|
+
obj.disconnect = DisconnectRequest.codec().decode(reader, reader.uint32(), {
|
|
124
|
+
limits: opts.limits?.disconnect
|
|
125
|
+
});
|
|
126
|
+
break;
|
|
127
|
+
}
|
|
128
|
+
case 8: {
|
|
129
|
+
obj.pubsub = PSRequest.codec().decode(reader, reader.uint32(), {
|
|
130
|
+
limits: opts.limits?.pubsub
|
|
131
|
+
});
|
|
132
|
+
break;
|
|
133
|
+
}
|
|
134
|
+
case 9: {
|
|
135
|
+
obj.peerStore = PeerstoreRequest.codec().decode(reader, reader.uint32(), {
|
|
136
|
+
limits: opts.limits?.peerStore
|
|
137
|
+
});
|
|
138
|
+
break;
|
|
139
|
+
}
|
|
140
|
+
default: {
|
|
115
141
|
reader.skipType(tag & 7);
|
|
116
142
|
break;
|
|
143
|
+
}
|
|
117
144
|
}
|
|
118
145
|
}
|
|
119
146
|
return obj;
|
|
147
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
148
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
149
|
+
while (reader.pos < end) {
|
|
150
|
+
const tag = reader.uint32();
|
|
151
|
+
switch (tag >>> 3) {
|
|
152
|
+
case 1: {
|
|
153
|
+
yield {
|
|
154
|
+
field: `${prefix}.type`,
|
|
155
|
+
value: Request.Type.codec().decode(reader)
|
|
156
|
+
};
|
|
157
|
+
break;
|
|
158
|
+
}
|
|
159
|
+
case 2: {
|
|
160
|
+
yield* ConnectRequest.codec().stream(reader, reader.uint32(), `${prefix}.connect`, {
|
|
161
|
+
limits: opts.limits?.connect
|
|
162
|
+
});
|
|
163
|
+
break;
|
|
164
|
+
}
|
|
165
|
+
case 3: {
|
|
166
|
+
yield* StreamOpenRequest.codec().stream(reader, reader.uint32(), `${prefix}.streamOpen`, {
|
|
167
|
+
limits: opts.limits?.streamOpen
|
|
168
|
+
});
|
|
169
|
+
break;
|
|
170
|
+
}
|
|
171
|
+
case 4: {
|
|
172
|
+
yield* StreamHandlerRequest.codec().stream(reader, reader.uint32(), `${prefix}.streamHandler`, {
|
|
173
|
+
limits: opts.limits?.streamHandler
|
|
174
|
+
});
|
|
175
|
+
break;
|
|
176
|
+
}
|
|
177
|
+
case 5: {
|
|
178
|
+
yield* DHTRequest.codec().stream(reader, reader.uint32(), `${prefix}.dht`, {
|
|
179
|
+
limits: opts.limits?.dht
|
|
180
|
+
});
|
|
181
|
+
break;
|
|
182
|
+
}
|
|
183
|
+
case 6: {
|
|
184
|
+
yield* ConnManagerRequest.codec().stream(reader, reader.uint32(), `${prefix}.connManager`, {
|
|
185
|
+
limits: opts.limits?.connManager
|
|
186
|
+
});
|
|
187
|
+
break;
|
|
188
|
+
}
|
|
189
|
+
case 7: {
|
|
190
|
+
yield* DisconnectRequest.codec().stream(reader, reader.uint32(), `${prefix}.disconnect`, {
|
|
191
|
+
limits: opts.limits?.disconnect
|
|
192
|
+
});
|
|
193
|
+
break;
|
|
194
|
+
}
|
|
195
|
+
case 8: {
|
|
196
|
+
yield* PSRequest.codec().stream(reader, reader.uint32(), `${prefix}.pubsub`, {
|
|
197
|
+
limits: opts.limits?.pubsub
|
|
198
|
+
});
|
|
199
|
+
break;
|
|
200
|
+
}
|
|
201
|
+
case 9: {
|
|
202
|
+
yield* PeerstoreRequest.codec().stream(reader, reader.uint32(), `${prefix}.peerStore`, {
|
|
203
|
+
limits: opts.limits?.peerStore
|
|
204
|
+
});
|
|
205
|
+
break;
|
|
206
|
+
}
|
|
207
|
+
default: {
|
|
208
|
+
reader.skipType(tag & 7);
|
|
209
|
+
break;
|
|
210
|
+
}
|
|
211
|
+
}
|
|
212
|
+
}
|
|
120
213
|
});
|
|
121
214
|
}
|
|
122
215
|
return _codec;
|
|
123
216
|
};
|
|
124
|
-
|
|
217
|
+
function encode(obj) {
|
|
125
218
|
return encodeMessage(obj, Request.codec());
|
|
126
|
-
}
|
|
127
|
-
Request.
|
|
128
|
-
|
|
129
|
-
|
|
219
|
+
}
|
|
220
|
+
Request.encode = encode;
|
|
221
|
+
function decode(buf, opts) {
|
|
222
|
+
return decodeMessage(buf, Request.codec(), opts);
|
|
223
|
+
}
|
|
224
|
+
Request.decode = decode;
|
|
225
|
+
function stream(buf, opts) {
|
|
226
|
+
return streamMessage(buf, Request.codec(), opts);
|
|
227
|
+
}
|
|
228
|
+
Request.stream = stream;
|
|
130
229
|
})(Request || (Request = {}));
|
|
131
230
|
export var Response;
|
|
132
231
|
(function (Response) {
|
|
@@ -172,7 +271,7 @@ export var Response;
|
|
|
172
271
|
w.uint32(42);
|
|
173
272
|
DHTResponse.codec().encode(obj.dht, w);
|
|
174
273
|
}
|
|
175
|
-
if (obj.peers != null) {
|
|
274
|
+
if (obj.peers != null && obj.peers.length > 0) {
|
|
176
275
|
for (const value of obj.peers) {
|
|
177
276
|
w.uint32(50);
|
|
178
277
|
PeerInfo.codec().encode(value, w);
|
|
@@ -189,7 +288,7 @@ export var Response;
|
|
|
189
288
|
if (opts.lengthDelimited !== false) {
|
|
190
289
|
w.ldelim();
|
|
191
290
|
}
|
|
192
|
-
}, (reader, length) => {
|
|
291
|
+
}, (reader, length, opts = {}) => {
|
|
193
292
|
const obj = {
|
|
194
293
|
peers: []
|
|
195
294
|
};
|
|
@@ -197,46 +296,150 @@ export var Response;
|
|
|
197
296
|
while (reader.pos < end) {
|
|
198
297
|
const tag = reader.uint32();
|
|
199
298
|
switch (tag >>> 3) {
|
|
200
|
-
case 1:
|
|
299
|
+
case 1: {
|
|
201
300
|
obj.type = Response.Type.codec().decode(reader);
|
|
202
301
|
break;
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
break;
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
break;
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
break;
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
302
|
+
}
|
|
303
|
+
case 2: {
|
|
304
|
+
obj.error = ErrorResponse.codec().decode(reader, reader.uint32(), {
|
|
305
|
+
limits: opts.limits?.error
|
|
306
|
+
});
|
|
307
|
+
break;
|
|
308
|
+
}
|
|
309
|
+
case 3: {
|
|
310
|
+
obj.streamInfo = StreamInfo.codec().decode(reader, reader.uint32(), {
|
|
311
|
+
limits: opts.limits?.streamInfo
|
|
312
|
+
});
|
|
313
|
+
break;
|
|
314
|
+
}
|
|
315
|
+
case 4: {
|
|
316
|
+
obj.identify = IdentifyResponse.codec().decode(reader, reader.uint32(), {
|
|
317
|
+
limits: opts.limits?.identify
|
|
318
|
+
});
|
|
319
|
+
break;
|
|
320
|
+
}
|
|
321
|
+
case 5: {
|
|
322
|
+
obj.dht = DHTResponse.codec().decode(reader, reader.uint32(), {
|
|
323
|
+
limits: opts.limits?.dht
|
|
324
|
+
});
|
|
325
|
+
break;
|
|
326
|
+
}
|
|
327
|
+
case 6: {
|
|
328
|
+
if (opts.limits?.peers != null && obj.peers.length === opts.limits.peers) {
|
|
329
|
+
throw new MaxLengthError('Decode error - repeated field "peers" had too many elements');
|
|
330
|
+
}
|
|
331
|
+
obj.peers.push(PeerInfo.codec().decode(reader, reader.uint32(), {
|
|
332
|
+
limits: opts.limits?.peers$
|
|
333
|
+
}));
|
|
334
|
+
break;
|
|
335
|
+
}
|
|
336
|
+
case 7: {
|
|
337
|
+
obj.pubsub = PSResponse.codec().decode(reader, reader.uint32(), {
|
|
338
|
+
limits: opts.limits?.pubsub
|
|
339
|
+
});
|
|
340
|
+
break;
|
|
341
|
+
}
|
|
342
|
+
case 8: {
|
|
343
|
+
obj.peerStore = PeerstoreResponse.codec().decode(reader, reader.uint32(), {
|
|
344
|
+
limits: opts.limits?.peerStore
|
|
345
|
+
});
|
|
346
|
+
break;
|
|
347
|
+
}
|
|
348
|
+
default: {
|
|
225
349
|
reader.skipType(tag & 7);
|
|
226
350
|
break;
|
|
351
|
+
}
|
|
227
352
|
}
|
|
228
353
|
}
|
|
229
354
|
return obj;
|
|
355
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
356
|
+
const obj = {
|
|
357
|
+
peers: 0
|
|
358
|
+
};
|
|
359
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
360
|
+
while (reader.pos < end) {
|
|
361
|
+
const tag = reader.uint32();
|
|
362
|
+
switch (tag >>> 3) {
|
|
363
|
+
case 1: {
|
|
364
|
+
yield {
|
|
365
|
+
field: `${prefix}.type`,
|
|
366
|
+
value: Response.Type.codec().decode(reader)
|
|
367
|
+
};
|
|
368
|
+
break;
|
|
369
|
+
}
|
|
370
|
+
case 2: {
|
|
371
|
+
yield* ErrorResponse.codec().stream(reader, reader.uint32(), `${prefix}.error`, {
|
|
372
|
+
limits: opts.limits?.error
|
|
373
|
+
});
|
|
374
|
+
break;
|
|
375
|
+
}
|
|
376
|
+
case 3: {
|
|
377
|
+
yield* StreamInfo.codec().stream(reader, reader.uint32(), `${prefix}.streamInfo`, {
|
|
378
|
+
limits: opts.limits?.streamInfo
|
|
379
|
+
});
|
|
380
|
+
break;
|
|
381
|
+
}
|
|
382
|
+
case 4: {
|
|
383
|
+
yield* IdentifyResponse.codec().stream(reader, reader.uint32(), `${prefix}.identify`, {
|
|
384
|
+
limits: opts.limits?.identify
|
|
385
|
+
});
|
|
386
|
+
break;
|
|
387
|
+
}
|
|
388
|
+
case 5: {
|
|
389
|
+
yield* DHTResponse.codec().stream(reader, reader.uint32(), `${prefix}.dht`, {
|
|
390
|
+
limits: opts.limits?.dht
|
|
391
|
+
});
|
|
392
|
+
break;
|
|
393
|
+
}
|
|
394
|
+
case 6: {
|
|
395
|
+
if (opts.limits?.peers != null && obj.peers === opts.limits.peers) {
|
|
396
|
+
throw new MaxLengthError('Streaming decode error - repeated field "peers" had too many elements');
|
|
397
|
+
}
|
|
398
|
+
for (const evt of PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peers[]`, {
|
|
399
|
+
limits: opts.limits?.peers$
|
|
400
|
+
})) {
|
|
401
|
+
yield {
|
|
402
|
+
...evt,
|
|
403
|
+
index: obj.peers
|
|
404
|
+
};
|
|
405
|
+
}
|
|
406
|
+
obj.peers++;
|
|
407
|
+
break;
|
|
408
|
+
}
|
|
409
|
+
case 7: {
|
|
410
|
+
yield* PSResponse.codec().stream(reader, reader.uint32(), `${prefix}.pubsub`, {
|
|
411
|
+
limits: opts.limits?.pubsub
|
|
412
|
+
});
|
|
413
|
+
break;
|
|
414
|
+
}
|
|
415
|
+
case 8: {
|
|
416
|
+
yield* PeerstoreResponse.codec().stream(reader, reader.uint32(), `${prefix}.peerStore`, {
|
|
417
|
+
limits: opts.limits?.peerStore
|
|
418
|
+
});
|
|
419
|
+
break;
|
|
420
|
+
}
|
|
421
|
+
default: {
|
|
422
|
+
reader.skipType(tag & 7);
|
|
423
|
+
break;
|
|
424
|
+
}
|
|
425
|
+
}
|
|
426
|
+
}
|
|
230
427
|
});
|
|
231
428
|
}
|
|
232
429
|
return _codec;
|
|
233
430
|
};
|
|
234
|
-
|
|
431
|
+
function encode(obj) {
|
|
235
432
|
return encodeMessage(obj, Response.codec());
|
|
236
|
-
}
|
|
237
|
-
Response.
|
|
238
|
-
|
|
239
|
-
|
|
433
|
+
}
|
|
434
|
+
Response.encode = encode;
|
|
435
|
+
function decode(buf, opts) {
|
|
436
|
+
return decodeMessage(buf, Response.codec(), opts);
|
|
437
|
+
}
|
|
438
|
+
Response.decode = decode;
|
|
439
|
+
function stream(buf, opts) {
|
|
440
|
+
return streamMessage(buf, Response.codec(), opts);
|
|
441
|
+
}
|
|
442
|
+
Response.stream = stream;
|
|
240
443
|
})(Response || (Response = {}));
|
|
241
444
|
export var IdentifyResponse;
|
|
242
445
|
(function (IdentifyResponse) {
|
|
@@ -251,7 +454,7 @@ export var IdentifyResponse;
|
|
|
251
454
|
w.uint32(10);
|
|
252
455
|
w.bytes(obj.id);
|
|
253
456
|
}
|
|
254
|
-
if (obj.addrs != null) {
|
|
457
|
+
if (obj.addrs != null && obj.addrs.length > 0) {
|
|
255
458
|
for (const value of obj.addrs) {
|
|
256
459
|
w.uint32(18);
|
|
257
460
|
w.bytes(value);
|
|
@@ -260,37 +463,82 @@ export var IdentifyResponse;
|
|
|
260
463
|
if (opts.lengthDelimited !== false) {
|
|
261
464
|
w.ldelim();
|
|
262
465
|
}
|
|
263
|
-
}, (reader, length) => {
|
|
466
|
+
}, (reader, length, opts = {}) => {
|
|
264
467
|
const obj = {
|
|
265
|
-
id:
|
|
468
|
+
id: uint8ArrayAlloc(0),
|
|
266
469
|
addrs: []
|
|
267
470
|
};
|
|
268
471
|
const end = length == null ? reader.len : reader.pos + length;
|
|
269
472
|
while (reader.pos < end) {
|
|
270
473
|
const tag = reader.uint32();
|
|
271
474
|
switch (tag >>> 3) {
|
|
272
|
-
case 1:
|
|
475
|
+
case 1: {
|
|
273
476
|
obj.id = reader.bytes();
|
|
274
477
|
break;
|
|
275
|
-
|
|
478
|
+
}
|
|
479
|
+
case 2: {
|
|
480
|
+
if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
|
|
481
|
+
throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements');
|
|
482
|
+
}
|
|
276
483
|
obj.addrs.push(reader.bytes());
|
|
277
484
|
break;
|
|
278
|
-
|
|
485
|
+
}
|
|
486
|
+
default: {
|
|
279
487
|
reader.skipType(tag & 7);
|
|
280
488
|
break;
|
|
489
|
+
}
|
|
281
490
|
}
|
|
282
491
|
}
|
|
283
492
|
return obj;
|
|
493
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
494
|
+
const obj = {
|
|
495
|
+
addrs: 0
|
|
496
|
+
};
|
|
497
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
498
|
+
while (reader.pos < end) {
|
|
499
|
+
const tag = reader.uint32();
|
|
500
|
+
switch (tag >>> 3) {
|
|
501
|
+
case 1: {
|
|
502
|
+
yield {
|
|
503
|
+
field: `${prefix}.id`,
|
|
504
|
+
value: reader.bytes()
|
|
505
|
+
};
|
|
506
|
+
break;
|
|
507
|
+
}
|
|
508
|
+
case 2: {
|
|
509
|
+
if (opts.limits?.addrs != null && obj.addrs === opts.limits.addrs) {
|
|
510
|
+
throw new MaxLengthError('Streaming decode error - repeated field "addrs" had too many elements');
|
|
511
|
+
}
|
|
512
|
+
yield {
|
|
513
|
+
field: `${prefix}.addrs[]`,
|
|
514
|
+
index: obj.addrs,
|
|
515
|
+
value: reader.bytes()
|
|
516
|
+
};
|
|
517
|
+
obj.addrs++;
|
|
518
|
+
break;
|
|
519
|
+
}
|
|
520
|
+
default: {
|
|
521
|
+
reader.skipType(tag & 7);
|
|
522
|
+
break;
|
|
523
|
+
}
|
|
524
|
+
}
|
|
525
|
+
}
|
|
284
526
|
});
|
|
285
527
|
}
|
|
286
528
|
return _codec;
|
|
287
529
|
};
|
|
288
|
-
|
|
530
|
+
function encode(obj) {
|
|
289
531
|
return encodeMessage(obj, IdentifyResponse.codec());
|
|
290
|
-
}
|
|
291
|
-
IdentifyResponse.
|
|
292
|
-
|
|
293
|
-
|
|
532
|
+
}
|
|
533
|
+
IdentifyResponse.encode = encode;
|
|
534
|
+
function decode(buf, opts) {
|
|
535
|
+
return decodeMessage(buf, IdentifyResponse.codec(), opts);
|
|
536
|
+
}
|
|
537
|
+
IdentifyResponse.decode = decode;
|
|
538
|
+
function stream(buf, opts) {
|
|
539
|
+
return streamMessage(buf, IdentifyResponse.codec(), opts);
|
|
540
|
+
}
|
|
541
|
+
IdentifyResponse.stream = stream;
|
|
294
542
|
})(IdentifyResponse || (IdentifyResponse = {}));
|
|
295
543
|
export var ConnectRequest;
|
|
296
544
|
(function (ConnectRequest) {
|
|
@@ -305,7 +553,7 @@ export var ConnectRequest;
|
|
|
305
553
|
w.uint32(10);
|
|
306
554
|
w.bytes(obj.peer);
|
|
307
555
|
}
|
|
308
|
-
if (obj.addrs != null) {
|
|
556
|
+
if (obj.addrs != null && obj.addrs.length > 0) {
|
|
309
557
|
for (const value of obj.addrs) {
|
|
310
558
|
w.uint32(18);
|
|
311
559
|
w.bytes(value);
|
|
@@ -318,40 +566,93 @@ export var ConnectRequest;
|
|
|
318
566
|
if (opts.lengthDelimited !== false) {
|
|
319
567
|
w.ldelim();
|
|
320
568
|
}
|
|
321
|
-
}, (reader, length) => {
|
|
569
|
+
}, (reader, length, opts = {}) => {
|
|
322
570
|
const obj = {
|
|
323
|
-
peer:
|
|
571
|
+
peer: uint8ArrayAlloc(0),
|
|
324
572
|
addrs: []
|
|
325
573
|
};
|
|
326
574
|
const end = length == null ? reader.len : reader.pos + length;
|
|
327
575
|
while (reader.pos < end) {
|
|
328
576
|
const tag = reader.uint32();
|
|
329
577
|
switch (tag >>> 3) {
|
|
330
|
-
case 1:
|
|
578
|
+
case 1: {
|
|
331
579
|
obj.peer = reader.bytes();
|
|
332
580
|
break;
|
|
333
|
-
|
|
581
|
+
}
|
|
582
|
+
case 2: {
|
|
583
|
+
if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
|
|
584
|
+
throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements');
|
|
585
|
+
}
|
|
334
586
|
obj.addrs.push(reader.bytes());
|
|
335
587
|
break;
|
|
336
|
-
|
|
588
|
+
}
|
|
589
|
+
case 3: {
|
|
337
590
|
obj.timeout = reader.int64();
|
|
338
591
|
break;
|
|
339
|
-
|
|
592
|
+
}
|
|
593
|
+
default: {
|
|
340
594
|
reader.skipType(tag & 7);
|
|
341
595
|
break;
|
|
596
|
+
}
|
|
342
597
|
}
|
|
343
598
|
}
|
|
344
599
|
return obj;
|
|
600
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
601
|
+
const obj = {
|
|
602
|
+
addrs: 0
|
|
603
|
+
};
|
|
604
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
605
|
+
while (reader.pos < end) {
|
|
606
|
+
const tag = reader.uint32();
|
|
607
|
+
switch (tag >>> 3) {
|
|
608
|
+
case 1: {
|
|
609
|
+
yield {
|
|
610
|
+
field: `${prefix}.peer`,
|
|
611
|
+
value: reader.bytes()
|
|
612
|
+
};
|
|
613
|
+
break;
|
|
614
|
+
}
|
|
615
|
+
case 2: {
|
|
616
|
+
if (opts.limits?.addrs != null && obj.addrs === opts.limits.addrs) {
|
|
617
|
+
throw new MaxLengthError('Streaming decode error - repeated field "addrs" had too many elements');
|
|
618
|
+
}
|
|
619
|
+
yield {
|
|
620
|
+
field: `${prefix}.addrs[]`,
|
|
621
|
+
index: obj.addrs,
|
|
622
|
+
value: reader.bytes()
|
|
623
|
+
};
|
|
624
|
+
obj.addrs++;
|
|
625
|
+
break;
|
|
626
|
+
}
|
|
627
|
+
case 3: {
|
|
628
|
+
yield {
|
|
629
|
+
field: `${prefix}.timeout`,
|
|
630
|
+
value: reader.int64()
|
|
631
|
+
};
|
|
632
|
+
break;
|
|
633
|
+
}
|
|
634
|
+
default: {
|
|
635
|
+
reader.skipType(tag & 7);
|
|
636
|
+
break;
|
|
637
|
+
}
|
|
638
|
+
}
|
|
639
|
+
}
|
|
345
640
|
});
|
|
346
641
|
}
|
|
347
642
|
return _codec;
|
|
348
643
|
};
|
|
349
|
-
|
|
644
|
+
function encode(obj) {
|
|
350
645
|
return encodeMessage(obj, ConnectRequest.codec());
|
|
351
|
-
}
|
|
352
|
-
ConnectRequest.
|
|
353
|
-
|
|
354
|
-
|
|
646
|
+
}
|
|
647
|
+
ConnectRequest.encode = encode;
|
|
648
|
+
function decode(buf, opts) {
|
|
649
|
+
return decodeMessage(buf, ConnectRequest.codec(), opts);
|
|
650
|
+
}
|
|
651
|
+
ConnectRequest.decode = decode;
|
|
652
|
+
function stream(buf, opts) {
|
|
653
|
+
return streamMessage(buf, ConnectRequest.codec(), opts);
|
|
654
|
+
}
|
|
655
|
+
ConnectRequest.stream = stream;
|
|
355
656
|
})(ConnectRequest || (ConnectRequest = {}));
|
|
356
657
|
export var StreamOpenRequest;
|
|
357
658
|
(function (StreamOpenRequest) {
|
|
@@ -366,7 +667,7 @@ export var StreamOpenRequest;
|
|
|
366
667
|
w.uint32(10);
|
|
367
668
|
w.bytes(obj.peer);
|
|
368
669
|
}
|
|
369
|
-
if (obj.proto != null) {
|
|
670
|
+
if (obj.proto != null && obj.proto.length > 0) {
|
|
370
671
|
for (const value of obj.proto) {
|
|
371
672
|
w.uint32(18);
|
|
372
673
|
w.string(value);
|
|
@@ -379,40 +680,93 @@ export var StreamOpenRequest;
|
|
|
379
680
|
if (opts.lengthDelimited !== false) {
|
|
380
681
|
w.ldelim();
|
|
381
682
|
}
|
|
382
|
-
}, (reader, length) => {
|
|
683
|
+
}, (reader, length, opts = {}) => {
|
|
383
684
|
const obj = {
|
|
384
|
-
peer:
|
|
685
|
+
peer: uint8ArrayAlloc(0),
|
|
385
686
|
proto: []
|
|
386
687
|
};
|
|
387
688
|
const end = length == null ? reader.len : reader.pos + length;
|
|
388
689
|
while (reader.pos < end) {
|
|
389
690
|
const tag = reader.uint32();
|
|
390
691
|
switch (tag >>> 3) {
|
|
391
|
-
case 1:
|
|
692
|
+
case 1: {
|
|
392
693
|
obj.peer = reader.bytes();
|
|
393
694
|
break;
|
|
394
|
-
|
|
695
|
+
}
|
|
696
|
+
case 2: {
|
|
697
|
+
if (opts.limits?.proto != null && obj.proto.length === opts.limits.proto) {
|
|
698
|
+
throw new MaxLengthError('Decode error - repeated field "proto" had too many elements');
|
|
699
|
+
}
|
|
395
700
|
obj.proto.push(reader.string());
|
|
396
701
|
break;
|
|
397
|
-
|
|
702
|
+
}
|
|
703
|
+
case 3: {
|
|
398
704
|
obj.timeout = reader.int64();
|
|
399
705
|
break;
|
|
400
|
-
|
|
706
|
+
}
|
|
707
|
+
default: {
|
|
401
708
|
reader.skipType(tag & 7);
|
|
402
709
|
break;
|
|
710
|
+
}
|
|
403
711
|
}
|
|
404
712
|
}
|
|
405
713
|
return obj;
|
|
714
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
715
|
+
const obj = {
|
|
716
|
+
proto: 0
|
|
717
|
+
};
|
|
718
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
719
|
+
while (reader.pos < end) {
|
|
720
|
+
const tag = reader.uint32();
|
|
721
|
+
switch (tag >>> 3) {
|
|
722
|
+
case 1: {
|
|
723
|
+
yield {
|
|
724
|
+
field: `${prefix}.peer`,
|
|
725
|
+
value: reader.bytes()
|
|
726
|
+
};
|
|
727
|
+
break;
|
|
728
|
+
}
|
|
729
|
+
case 2: {
|
|
730
|
+
if (opts.limits?.proto != null && obj.proto === opts.limits.proto) {
|
|
731
|
+
throw new MaxLengthError('Streaming decode error - repeated field "proto" had too many elements');
|
|
732
|
+
}
|
|
733
|
+
yield {
|
|
734
|
+
field: `${prefix}.proto[]`,
|
|
735
|
+
index: obj.proto,
|
|
736
|
+
value: reader.string()
|
|
737
|
+
};
|
|
738
|
+
obj.proto++;
|
|
739
|
+
break;
|
|
740
|
+
}
|
|
741
|
+
case 3: {
|
|
742
|
+
yield {
|
|
743
|
+
field: `${prefix}.timeout`,
|
|
744
|
+
value: reader.int64()
|
|
745
|
+
};
|
|
746
|
+
break;
|
|
747
|
+
}
|
|
748
|
+
default: {
|
|
749
|
+
reader.skipType(tag & 7);
|
|
750
|
+
break;
|
|
751
|
+
}
|
|
752
|
+
}
|
|
753
|
+
}
|
|
406
754
|
});
|
|
407
755
|
}
|
|
408
756
|
return _codec;
|
|
409
757
|
};
|
|
410
|
-
|
|
758
|
+
function encode(obj) {
|
|
411
759
|
return encodeMessage(obj, StreamOpenRequest.codec());
|
|
412
|
-
}
|
|
413
|
-
StreamOpenRequest.
|
|
414
|
-
|
|
415
|
-
|
|
760
|
+
}
|
|
761
|
+
StreamOpenRequest.encode = encode;
|
|
762
|
+
function decode(buf, opts) {
|
|
763
|
+
return decodeMessage(buf, StreamOpenRequest.codec(), opts);
|
|
764
|
+
}
|
|
765
|
+
StreamOpenRequest.decode = decode;
|
|
766
|
+
function stream(buf, opts) {
|
|
767
|
+
return streamMessage(buf, StreamOpenRequest.codec(), opts);
|
|
768
|
+
}
|
|
769
|
+
StreamOpenRequest.stream = stream;
|
|
416
770
|
})(StreamOpenRequest || (StreamOpenRequest = {}));
|
|
417
771
|
export var StreamHandlerRequest;
|
|
418
772
|
(function (StreamHandlerRequest) {
|
|
@@ -427,7 +781,7 @@ export var StreamHandlerRequest;
|
|
|
427
781
|
w.uint32(10);
|
|
428
782
|
w.bytes(obj.addr);
|
|
429
783
|
}
|
|
430
|
-
if (obj.proto != null) {
|
|
784
|
+
if (obj.proto != null && obj.proto.length > 0) {
|
|
431
785
|
for (const value of obj.proto) {
|
|
432
786
|
w.uint32(18);
|
|
433
787
|
w.string(value);
|
|
@@ -436,37 +790,82 @@ export var StreamHandlerRequest;
|
|
|
436
790
|
if (opts.lengthDelimited !== false) {
|
|
437
791
|
w.ldelim();
|
|
438
792
|
}
|
|
439
|
-
}, (reader, length) => {
|
|
793
|
+
}, (reader, length, opts = {}) => {
|
|
440
794
|
const obj = {
|
|
441
|
-
addr:
|
|
795
|
+
addr: uint8ArrayAlloc(0),
|
|
442
796
|
proto: []
|
|
443
797
|
};
|
|
444
798
|
const end = length == null ? reader.len : reader.pos + length;
|
|
445
799
|
while (reader.pos < end) {
|
|
446
800
|
const tag = reader.uint32();
|
|
447
801
|
switch (tag >>> 3) {
|
|
448
|
-
case 1:
|
|
802
|
+
case 1: {
|
|
449
803
|
obj.addr = reader.bytes();
|
|
450
804
|
break;
|
|
451
|
-
|
|
805
|
+
}
|
|
806
|
+
case 2: {
|
|
807
|
+
if (opts.limits?.proto != null && obj.proto.length === opts.limits.proto) {
|
|
808
|
+
throw new MaxLengthError('Decode error - repeated field "proto" had too many elements');
|
|
809
|
+
}
|
|
452
810
|
obj.proto.push(reader.string());
|
|
453
811
|
break;
|
|
454
|
-
|
|
812
|
+
}
|
|
813
|
+
default: {
|
|
455
814
|
reader.skipType(tag & 7);
|
|
456
815
|
break;
|
|
816
|
+
}
|
|
457
817
|
}
|
|
458
818
|
}
|
|
459
819
|
return obj;
|
|
820
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
821
|
+
const obj = {
|
|
822
|
+
proto: 0
|
|
823
|
+
};
|
|
824
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
825
|
+
while (reader.pos < end) {
|
|
826
|
+
const tag = reader.uint32();
|
|
827
|
+
switch (tag >>> 3) {
|
|
828
|
+
case 1: {
|
|
829
|
+
yield {
|
|
830
|
+
field: `${prefix}.addr`,
|
|
831
|
+
value: reader.bytes()
|
|
832
|
+
};
|
|
833
|
+
break;
|
|
834
|
+
}
|
|
835
|
+
case 2: {
|
|
836
|
+
if (opts.limits?.proto != null && obj.proto === opts.limits.proto) {
|
|
837
|
+
throw new MaxLengthError('Streaming decode error - repeated field "proto" had too many elements');
|
|
838
|
+
}
|
|
839
|
+
yield {
|
|
840
|
+
field: `${prefix}.proto[]`,
|
|
841
|
+
index: obj.proto,
|
|
842
|
+
value: reader.string()
|
|
843
|
+
};
|
|
844
|
+
obj.proto++;
|
|
845
|
+
break;
|
|
846
|
+
}
|
|
847
|
+
default: {
|
|
848
|
+
reader.skipType(tag & 7);
|
|
849
|
+
break;
|
|
850
|
+
}
|
|
851
|
+
}
|
|
852
|
+
}
|
|
460
853
|
});
|
|
461
854
|
}
|
|
462
855
|
return _codec;
|
|
463
856
|
};
|
|
464
|
-
|
|
857
|
+
function encode(obj) {
|
|
465
858
|
return encodeMessage(obj, StreamHandlerRequest.codec());
|
|
466
|
-
}
|
|
467
|
-
StreamHandlerRequest.
|
|
468
|
-
|
|
469
|
-
|
|
859
|
+
}
|
|
860
|
+
StreamHandlerRequest.encode = encode;
|
|
861
|
+
function decode(buf, opts) {
|
|
862
|
+
return decodeMessage(buf, StreamHandlerRequest.codec(), opts);
|
|
863
|
+
}
|
|
864
|
+
StreamHandlerRequest.decode = decode;
|
|
865
|
+
function stream(buf, opts) {
|
|
866
|
+
return streamMessage(buf, StreamHandlerRequest.codec(), opts);
|
|
867
|
+
}
|
|
868
|
+
StreamHandlerRequest.stream = stream;
|
|
470
869
|
})(StreamHandlerRequest || (StreamHandlerRequest = {}));
|
|
471
870
|
export var ErrorResponse;
|
|
472
871
|
(function (ErrorResponse) {
|
|
@@ -484,7 +883,7 @@ export var ErrorResponse;
|
|
|
484
883
|
if (opts.lengthDelimited !== false) {
|
|
485
884
|
w.ldelim();
|
|
486
885
|
}
|
|
487
|
-
}, (reader, length) => {
|
|
886
|
+
}, (reader, length, opts = {}) => {
|
|
488
887
|
const obj = {
|
|
489
888
|
msg: ''
|
|
490
889
|
};
|
|
@@ -492,25 +891,51 @@ export var ErrorResponse;
|
|
|
492
891
|
while (reader.pos < end) {
|
|
493
892
|
const tag = reader.uint32();
|
|
494
893
|
switch (tag >>> 3) {
|
|
495
|
-
case 1:
|
|
894
|
+
case 1: {
|
|
496
895
|
obj.msg = reader.string();
|
|
497
896
|
break;
|
|
498
|
-
|
|
897
|
+
}
|
|
898
|
+
default: {
|
|
499
899
|
reader.skipType(tag & 7);
|
|
500
900
|
break;
|
|
901
|
+
}
|
|
501
902
|
}
|
|
502
903
|
}
|
|
503
904
|
return obj;
|
|
905
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
906
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
907
|
+
while (reader.pos < end) {
|
|
908
|
+
const tag = reader.uint32();
|
|
909
|
+
switch (tag >>> 3) {
|
|
910
|
+
case 1: {
|
|
911
|
+
yield {
|
|
912
|
+
field: `${prefix}.msg`,
|
|
913
|
+
value: reader.string()
|
|
914
|
+
};
|
|
915
|
+
break;
|
|
916
|
+
}
|
|
917
|
+
default: {
|
|
918
|
+
reader.skipType(tag & 7);
|
|
919
|
+
break;
|
|
920
|
+
}
|
|
921
|
+
}
|
|
922
|
+
}
|
|
504
923
|
});
|
|
505
924
|
}
|
|
506
925
|
return _codec;
|
|
507
926
|
};
|
|
508
|
-
|
|
927
|
+
function encode(obj) {
|
|
509
928
|
return encodeMessage(obj, ErrorResponse.codec());
|
|
510
|
-
}
|
|
511
|
-
ErrorResponse.
|
|
512
|
-
|
|
513
|
-
|
|
929
|
+
}
|
|
930
|
+
ErrorResponse.encode = encode;
|
|
931
|
+
function decode(buf, opts) {
|
|
932
|
+
return decodeMessage(buf, ErrorResponse.codec(), opts);
|
|
933
|
+
}
|
|
934
|
+
ErrorResponse.decode = decode;
|
|
935
|
+
function stream(buf, opts) {
|
|
936
|
+
return streamMessage(buf, ErrorResponse.codec(), opts);
|
|
937
|
+
}
|
|
938
|
+
ErrorResponse.stream = stream;
|
|
514
939
|
})(ErrorResponse || (ErrorResponse = {}));
|
|
515
940
|
export var StreamInfo;
|
|
516
941
|
(function (StreamInfo) {
|
|
@@ -536,41 +961,83 @@ export var StreamInfo;
|
|
|
536
961
|
if (opts.lengthDelimited !== false) {
|
|
537
962
|
w.ldelim();
|
|
538
963
|
}
|
|
539
|
-
}, (reader, length) => {
|
|
964
|
+
}, (reader, length, opts = {}) => {
|
|
540
965
|
const obj = {
|
|
541
|
-
peer:
|
|
542
|
-
addr:
|
|
966
|
+
peer: uint8ArrayAlloc(0),
|
|
967
|
+
addr: uint8ArrayAlloc(0),
|
|
543
968
|
proto: ''
|
|
544
969
|
};
|
|
545
970
|
const end = length == null ? reader.len : reader.pos + length;
|
|
546
971
|
while (reader.pos < end) {
|
|
547
972
|
const tag = reader.uint32();
|
|
548
973
|
switch (tag >>> 3) {
|
|
549
|
-
case 1:
|
|
974
|
+
case 1: {
|
|
550
975
|
obj.peer = reader.bytes();
|
|
551
976
|
break;
|
|
552
|
-
|
|
977
|
+
}
|
|
978
|
+
case 2: {
|
|
553
979
|
obj.addr = reader.bytes();
|
|
554
980
|
break;
|
|
555
|
-
|
|
981
|
+
}
|
|
982
|
+
case 3: {
|
|
556
983
|
obj.proto = reader.string();
|
|
557
984
|
break;
|
|
558
|
-
|
|
985
|
+
}
|
|
986
|
+
default: {
|
|
559
987
|
reader.skipType(tag & 7);
|
|
560
988
|
break;
|
|
989
|
+
}
|
|
561
990
|
}
|
|
562
991
|
}
|
|
563
992
|
return obj;
|
|
993
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
994
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
995
|
+
while (reader.pos < end) {
|
|
996
|
+
const tag = reader.uint32();
|
|
997
|
+
switch (tag >>> 3) {
|
|
998
|
+
case 1: {
|
|
999
|
+
yield {
|
|
1000
|
+
field: `${prefix}.peer`,
|
|
1001
|
+
value: reader.bytes()
|
|
1002
|
+
};
|
|
1003
|
+
break;
|
|
1004
|
+
}
|
|
1005
|
+
case 2: {
|
|
1006
|
+
yield {
|
|
1007
|
+
field: `${prefix}.addr`,
|
|
1008
|
+
value: reader.bytes()
|
|
1009
|
+
};
|
|
1010
|
+
break;
|
|
1011
|
+
}
|
|
1012
|
+
case 3: {
|
|
1013
|
+
yield {
|
|
1014
|
+
field: `${prefix}.proto`,
|
|
1015
|
+
value: reader.string()
|
|
1016
|
+
};
|
|
1017
|
+
break;
|
|
1018
|
+
}
|
|
1019
|
+
default: {
|
|
1020
|
+
reader.skipType(tag & 7);
|
|
1021
|
+
break;
|
|
1022
|
+
}
|
|
1023
|
+
}
|
|
1024
|
+
}
|
|
564
1025
|
});
|
|
565
1026
|
}
|
|
566
1027
|
return _codec;
|
|
567
1028
|
};
|
|
568
|
-
|
|
1029
|
+
function encode(obj) {
|
|
569
1030
|
return encodeMessage(obj, StreamInfo.codec());
|
|
570
|
-
}
|
|
571
|
-
StreamInfo.
|
|
572
|
-
|
|
573
|
-
|
|
1031
|
+
}
|
|
1032
|
+
StreamInfo.encode = encode;
|
|
1033
|
+
function decode(buf, opts) {
|
|
1034
|
+
return decodeMessage(buf, StreamInfo.codec(), opts);
|
|
1035
|
+
}
|
|
1036
|
+
StreamInfo.decode = decode;
|
|
1037
|
+
function stream(buf, opts) {
|
|
1038
|
+
return streamMessage(buf, StreamInfo.codec(), opts);
|
|
1039
|
+
}
|
|
1040
|
+
StreamInfo.stream = stream;
|
|
574
1041
|
})(StreamInfo || (StreamInfo = {}));
|
|
575
1042
|
export var DHTRequest;
|
|
576
1043
|
(function (DHTRequest) {
|
|
@@ -641,49 +1108,123 @@ export var DHTRequest;
|
|
|
641
1108
|
if (opts.lengthDelimited !== false) {
|
|
642
1109
|
w.ldelim();
|
|
643
1110
|
}
|
|
644
|
-
}, (reader, length) => {
|
|
1111
|
+
}, (reader, length, opts = {}) => {
|
|
645
1112
|
const obj = {};
|
|
646
1113
|
const end = length == null ? reader.len : reader.pos + length;
|
|
647
1114
|
while (reader.pos < end) {
|
|
648
1115
|
const tag = reader.uint32();
|
|
649
1116
|
switch (tag >>> 3) {
|
|
650
|
-
case 1:
|
|
1117
|
+
case 1: {
|
|
651
1118
|
obj.type = DHTRequest.Type.codec().decode(reader);
|
|
652
1119
|
break;
|
|
653
|
-
|
|
1120
|
+
}
|
|
1121
|
+
case 2: {
|
|
654
1122
|
obj.peer = reader.bytes();
|
|
655
1123
|
break;
|
|
656
|
-
|
|
1124
|
+
}
|
|
1125
|
+
case 3: {
|
|
657
1126
|
obj.cid = reader.bytes();
|
|
658
1127
|
break;
|
|
659
|
-
|
|
1128
|
+
}
|
|
1129
|
+
case 4: {
|
|
660
1130
|
obj.key = reader.bytes();
|
|
661
1131
|
break;
|
|
662
|
-
|
|
1132
|
+
}
|
|
1133
|
+
case 5: {
|
|
663
1134
|
obj.value = reader.bytes();
|
|
664
1135
|
break;
|
|
665
|
-
|
|
1136
|
+
}
|
|
1137
|
+
case 6: {
|
|
666
1138
|
obj.count = reader.int32();
|
|
667
1139
|
break;
|
|
668
|
-
|
|
1140
|
+
}
|
|
1141
|
+
case 7: {
|
|
669
1142
|
obj.timeout = reader.int64();
|
|
670
1143
|
break;
|
|
671
|
-
|
|
1144
|
+
}
|
|
1145
|
+
default: {
|
|
672
1146
|
reader.skipType(tag & 7);
|
|
673
1147
|
break;
|
|
1148
|
+
}
|
|
674
1149
|
}
|
|
675
1150
|
}
|
|
676
1151
|
return obj;
|
|
1152
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
1153
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1154
|
+
while (reader.pos < end) {
|
|
1155
|
+
const tag = reader.uint32();
|
|
1156
|
+
switch (tag >>> 3) {
|
|
1157
|
+
case 1: {
|
|
1158
|
+
yield {
|
|
1159
|
+
field: `${prefix}.type`,
|
|
1160
|
+
value: DHTRequest.Type.codec().decode(reader)
|
|
1161
|
+
};
|
|
1162
|
+
break;
|
|
1163
|
+
}
|
|
1164
|
+
case 2: {
|
|
1165
|
+
yield {
|
|
1166
|
+
field: `${prefix}.peer`,
|
|
1167
|
+
value: reader.bytes()
|
|
1168
|
+
};
|
|
1169
|
+
break;
|
|
1170
|
+
}
|
|
1171
|
+
case 3: {
|
|
1172
|
+
yield {
|
|
1173
|
+
field: `${prefix}.cid`,
|
|
1174
|
+
value: reader.bytes()
|
|
1175
|
+
};
|
|
1176
|
+
break;
|
|
1177
|
+
}
|
|
1178
|
+
case 4: {
|
|
1179
|
+
yield {
|
|
1180
|
+
field: `${prefix}.key`,
|
|
1181
|
+
value: reader.bytes()
|
|
1182
|
+
};
|
|
1183
|
+
break;
|
|
1184
|
+
}
|
|
1185
|
+
case 5: {
|
|
1186
|
+
yield {
|
|
1187
|
+
field: `${prefix}.value`,
|
|
1188
|
+
value: reader.bytes()
|
|
1189
|
+
};
|
|
1190
|
+
break;
|
|
1191
|
+
}
|
|
1192
|
+
case 6: {
|
|
1193
|
+
yield {
|
|
1194
|
+
field: `${prefix}.count`,
|
|
1195
|
+
value: reader.int32()
|
|
1196
|
+
};
|
|
1197
|
+
break;
|
|
1198
|
+
}
|
|
1199
|
+
case 7: {
|
|
1200
|
+
yield {
|
|
1201
|
+
field: `${prefix}.timeout`,
|
|
1202
|
+
value: reader.int64()
|
|
1203
|
+
};
|
|
1204
|
+
break;
|
|
1205
|
+
}
|
|
1206
|
+
default: {
|
|
1207
|
+
reader.skipType(tag & 7);
|
|
1208
|
+
break;
|
|
1209
|
+
}
|
|
1210
|
+
}
|
|
1211
|
+
}
|
|
677
1212
|
});
|
|
678
1213
|
}
|
|
679
1214
|
return _codec;
|
|
680
1215
|
};
|
|
681
|
-
|
|
1216
|
+
function encode(obj) {
|
|
682
1217
|
return encodeMessage(obj, DHTRequest.codec());
|
|
683
|
-
}
|
|
684
|
-
DHTRequest.
|
|
685
|
-
|
|
686
|
-
|
|
1218
|
+
}
|
|
1219
|
+
DHTRequest.encode = encode;
|
|
1220
|
+
function decode(buf, opts) {
|
|
1221
|
+
return decodeMessage(buf, DHTRequest.codec(), opts);
|
|
1222
|
+
}
|
|
1223
|
+
DHTRequest.decode = decode;
|
|
1224
|
+
function stream(buf, opts) {
|
|
1225
|
+
return streamMessage(buf, DHTRequest.codec(), opts);
|
|
1226
|
+
}
|
|
1227
|
+
DHTRequest.stream = stream;
|
|
687
1228
|
})(DHTRequest || (DHTRequest = {}));
|
|
688
1229
|
export var DHTResponse;
|
|
689
1230
|
(function (DHTResponse) {
|
|
@@ -726,37 +1267,80 @@ export var DHTResponse;
|
|
|
726
1267
|
if (opts.lengthDelimited !== false) {
|
|
727
1268
|
w.ldelim();
|
|
728
1269
|
}
|
|
729
|
-
}, (reader, length) => {
|
|
1270
|
+
}, (reader, length, opts = {}) => {
|
|
730
1271
|
const obj = {};
|
|
731
1272
|
const end = length == null ? reader.len : reader.pos + length;
|
|
732
1273
|
while (reader.pos < end) {
|
|
733
1274
|
const tag = reader.uint32();
|
|
734
1275
|
switch (tag >>> 3) {
|
|
735
|
-
case 1:
|
|
1276
|
+
case 1: {
|
|
736
1277
|
obj.type = DHTResponse.Type.codec().decode(reader);
|
|
737
1278
|
break;
|
|
738
|
-
|
|
739
|
-
|
|
1279
|
+
}
|
|
1280
|
+
case 2: {
|
|
1281
|
+
obj.peer = PeerInfo.codec().decode(reader, reader.uint32(), {
|
|
1282
|
+
limits: opts.limits?.peer
|
|
1283
|
+
});
|
|
740
1284
|
break;
|
|
741
|
-
|
|
1285
|
+
}
|
|
1286
|
+
case 3: {
|
|
742
1287
|
obj.value = reader.bytes();
|
|
743
1288
|
break;
|
|
744
|
-
|
|
1289
|
+
}
|
|
1290
|
+
default: {
|
|
745
1291
|
reader.skipType(tag & 7);
|
|
746
1292
|
break;
|
|
1293
|
+
}
|
|
747
1294
|
}
|
|
748
1295
|
}
|
|
749
1296
|
return obj;
|
|
1297
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
1298
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1299
|
+
while (reader.pos < end) {
|
|
1300
|
+
const tag = reader.uint32();
|
|
1301
|
+
switch (tag >>> 3) {
|
|
1302
|
+
case 1: {
|
|
1303
|
+
yield {
|
|
1304
|
+
field: `${prefix}.type`,
|
|
1305
|
+
value: DHTResponse.Type.codec().decode(reader)
|
|
1306
|
+
};
|
|
1307
|
+
break;
|
|
1308
|
+
}
|
|
1309
|
+
case 2: {
|
|
1310
|
+
yield* PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peer`, {
|
|
1311
|
+
limits: opts.limits?.peer
|
|
1312
|
+
});
|
|
1313
|
+
break;
|
|
1314
|
+
}
|
|
1315
|
+
case 3: {
|
|
1316
|
+
yield {
|
|
1317
|
+
field: `${prefix}.value`,
|
|
1318
|
+
value: reader.bytes()
|
|
1319
|
+
};
|
|
1320
|
+
break;
|
|
1321
|
+
}
|
|
1322
|
+
default: {
|
|
1323
|
+
reader.skipType(tag & 7);
|
|
1324
|
+
break;
|
|
1325
|
+
}
|
|
1326
|
+
}
|
|
1327
|
+
}
|
|
750
1328
|
});
|
|
751
1329
|
}
|
|
752
1330
|
return _codec;
|
|
753
1331
|
};
|
|
754
|
-
|
|
1332
|
+
function encode(obj) {
|
|
755
1333
|
return encodeMessage(obj, DHTResponse.codec());
|
|
756
|
-
}
|
|
757
|
-
DHTResponse.
|
|
758
|
-
|
|
759
|
-
|
|
1334
|
+
}
|
|
1335
|
+
DHTResponse.encode = encode;
|
|
1336
|
+
function decode(buf, opts) {
|
|
1337
|
+
return decodeMessage(buf, DHTResponse.codec(), opts);
|
|
1338
|
+
}
|
|
1339
|
+
DHTResponse.decode = decode;
|
|
1340
|
+
function stream(buf, opts) {
|
|
1341
|
+
return streamMessage(buf, DHTResponse.codec(), opts);
|
|
1342
|
+
}
|
|
1343
|
+
DHTResponse.stream = stream;
|
|
760
1344
|
})(DHTResponse || (DHTResponse = {}));
|
|
761
1345
|
export var PeerInfo;
|
|
762
1346
|
(function (PeerInfo) {
|
|
@@ -771,7 +1355,7 @@ export var PeerInfo;
|
|
|
771
1355
|
w.uint32(10);
|
|
772
1356
|
w.bytes(obj.id);
|
|
773
1357
|
}
|
|
774
|
-
if (obj.addrs != null) {
|
|
1358
|
+
if (obj.addrs != null && obj.addrs.length > 0) {
|
|
775
1359
|
for (const value of obj.addrs) {
|
|
776
1360
|
w.uint32(18);
|
|
777
1361
|
w.bytes(value);
|
|
@@ -780,37 +1364,82 @@ export var PeerInfo;
|
|
|
780
1364
|
if (opts.lengthDelimited !== false) {
|
|
781
1365
|
w.ldelim();
|
|
782
1366
|
}
|
|
783
|
-
}, (reader, length) => {
|
|
1367
|
+
}, (reader, length, opts = {}) => {
|
|
784
1368
|
const obj = {
|
|
785
|
-
id:
|
|
1369
|
+
id: uint8ArrayAlloc(0),
|
|
786
1370
|
addrs: []
|
|
787
1371
|
};
|
|
788
1372
|
const end = length == null ? reader.len : reader.pos + length;
|
|
789
1373
|
while (reader.pos < end) {
|
|
790
1374
|
const tag = reader.uint32();
|
|
791
1375
|
switch (tag >>> 3) {
|
|
792
|
-
case 1:
|
|
1376
|
+
case 1: {
|
|
793
1377
|
obj.id = reader.bytes();
|
|
794
1378
|
break;
|
|
795
|
-
|
|
1379
|
+
}
|
|
1380
|
+
case 2: {
|
|
1381
|
+
if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
|
|
1382
|
+
throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements');
|
|
1383
|
+
}
|
|
796
1384
|
obj.addrs.push(reader.bytes());
|
|
797
1385
|
break;
|
|
798
|
-
|
|
1386
|
+
}
|
|
1387
|
+
default: {
|
|
799
1388
|
reader.skipType(tag & 7);
|
|
800
1389
|
break;
|
|
1390
|
+
}
|
|
801
1391
|
}
|
|
802
1392
|
}
|
|
803
1393
|
return obj;
|
|
1394
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
1395
|
+
const obj = {
|
|
1396
|
+
addrs: 0
|
|
1397
|
+
};
|
|
1398
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1399
|
+
while (reader.pos < end) {
|
|
1400
|
+
const tag = reader.uint32();
|
|
1401
|
+
switch (tag >>> 3) {
|
|
1402
|
+
case 1: {
|
|
1403
|
+
yield {
|
|
1404
|
+
field: `${prefix}.id`,
|
|
1405
|
+
value: reader.bytes()
|
|
1406
|
+
};
|
|
1407
|
+
break;
|
|
1408
|
+
}
|
|
1409
|
+
case 2: {
|
|
1410
|
+
if (opts.limits?.addrs != null && obj.addrs === opts.limits.addrs) {
|
|
1411
|
+
throw new MaxLengthError('Streaming decode error - repeated field "addrs" had too many elements');
|
|
1412
|
+
}
|
|
1413
|
+
yield {
|
|
1414
|
+
field: `${prefix}.addrs[]`,
|
|
1415
|
+
index: obj.addrs,
|
|
1416
|
+
value: reader.bytes()
|
|
1417
|
+
};
|
|
1418
|
+
obj.addrs++;
|
|
1419
|
+
break;
|
|
1420
|
+
}
|
|
1421
|
+
default: {
|
|
1422
|
+
reader.skipType(tag & 7);
|
|
1423
|
+
break;
|
|
1424
|
+
}
|
|
1425
|
+
}
|
|
1426
|
+
}
|
|
804
1427
|
});
|
|
805
1428
|
}
|
|
806
1429
|
return _codec;
|
|
807
1430
|
};
|
|
808
|
-
|
|
1431
|
+
function encode(obj) {
|
|
809
1432
|
return encodeMessage(obj, PeerInfo.codec());
|
|
810
|
-
}
|
|
811
|
-
PeerInfo.
|
|
812
|
-
|
|
813
|
-
|
|
1433
|
+
}
|
|
1434
|
+
PeerInfo.encode = encode;
|
|
1435
|
+
function decode(buf, opts) {
|
|
1436
|
+
return decodeMessage(buf, PeerInfo.codec(), opts);
|
|
1437
|
+
}
|
|
1438
|
+
PeerInfo.decode = decode;
|
|
1439
|
+
function stream(buf, opts) {
|
|
1440
|
+
return streamMessage(buf, PeerInfo.codec(), opts);
|
|
1441
|
+
}
|
|
1442
|
+
PeerInfo.stream = stream;
|
|
814
1443
|
})(PeerInfo || (PeerInfo = {}));
|
|
815
1444
|
export var ConnManagerRequest;
|
|
816
1445
|
(function (ConnManagerRequest) {
|
|
@@ -857,40 +1486,90 @@ export var ConnManagerRequest;
|
|
|
857
1486
|
if (opts.lengthDelimited !== false) {
|
|
858
1487
|
w.ldelim();
|
|
859
1488
|
}
|
|
860
|
-
}, (reader, length) => {
|
|
1489
|
+
}, (reader, length, opts = {}) => {
|
|
861
1490
|
const obj = {};
|
|
862
1491
|
const end = length == null ? reader.len : reader.pos + length;
|
|
863
1492
|
while (reader.pos < end) {
|
|
864
1493
|
const tag = reader.uint32();
|
|
865
1494
|
switch (tag >>> 3) {
|
|
866
|
-
case 1:
|
|
1495
|
+
case 1: {
|
|
867
1496
|
obj.type = ConnManagerRequest.Type.codec().decode(reader);
|
|
868
1497
|
break;
|
|
869
|
-
|
|
1498
|
+
}
|
|
1499
|
+
case 2: {
|
|
870
1500
|
obj.peer = reader.bytes();
|
|
871
1501
|
break;
|
|
872
|
-
|
|
1502
|
+
}
|
|
1503
|
+
case 3: {
|
|
873
1504
|
obj.tag = reader.string();
|
|
874
1505
|
break;
|
|
875
|
-
|
|
1506
|
+
}
|
|
1507
|
+
case 4: {
|
|
876
1508
|
obj.weight = reader.int64();
|
|
877
1509
|
break;
|
|
878
|
-
|
|
1510
|
+
}
|
|
1511
|
+
default: {
|
|
879
1512
|
reader.skipType(tag & 7);
|
|
880
1513
|
break;
|
|
1514
|
+
}
|
|
881
1515
|
}
|
|
882
1516
|
}
|
|
883
1517
|
return obj;
|
|
1518
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
1519
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1520
|
+
while (reader.pos < end) {
|
|
1521
|
+
const tag = reader.uint32();
|
|
1522
|
+
switch (tag >>> 3) {
|
|
1523
|
+
case 1: {
|
|
1524
|
+
yield {
|
|
1525
|
+
field: `${prefix}.type`,
|
|
1526
|
+
value: ConnManagerRequest.Type.codec().decode(reader)
|
|
1527
|
+
};
|
|
1528
|
+
break;
|
|
1529
|
+
}
|
|
1530
|
+
case 2: {
|
|
1531
|
+
yield {
|
|
1532
|
+
field: `${prefix}.peer`,
|
|
1533
|
+
value: reader.bytes()
|
|
1534
|
+
};
|
|
1535
|
+
break;
|
|
1536
|
+
}
|
|
1537
|
+
case 3: {
|
|
1538
|
+
yield {
|
|
1539
|
+
field: `${prefix}.tag`,
|
|
1540
|
+
value: reader.string()
|
|
1541
|
+
};
|
|
1542
|
+
break;
|
|
1543
|
+
}
|
|
1544
|
+
case 4: {
|
|
1545
|
+
yield {
|
|
1546
|
+
field: `${prefix}.weight`,
|
|
1547
|
+
value: reader.int64()
|
|
1548
|
+
};
|
|
1549
|
+
break;
|
|
1550
|
+
}
|
|
1551
|
+
default: {
|
|
1552
|
+
reader.skipType(tag & 7);
|
|
1553
|
+
break;
|
|
1554
|
+
}
|
|
1555
|
+
}
|
|
1556
|
+
}
|
|
884
1557
|
});
|
|
885
1558
|
}
|
|
886
1559
|
return _codec;
|
|
887
1560
|
};
|
|
888
|
-
|
|
1561
|
+
function encode(obj) {
|
|
889
1562
|
return encodeMessage(obj, ConnManagerRequest.codec());
|
|
890
|
-
}
|
|
891
|
-
ConnManagerRequest.
|
|
892
|
-
|
|
893
|
-
|
|
1563
|
+
}
|
|
1564
|
+
ConnManagerRequest.encode = encode;
|
|
1565
|
+
function decode(buf, opts) {
|
|
1566
|
+
return decodeMessage(buf, ConnManagerRequest.codec(), opts);
|
|
1567
|
+
}
|
|
1568
|
+
ConnManagerRequest.decode = decode;
|
|
1569
|
+
function stream(buf, opts) {
|
|
1570
|
+
return streamMessage(buf, ConnManagerRequest.codec(), opts);
|
|
1571
|
+
}
|
|
1572
|
+
ConnManagerRequest.stream = stream;
|
|
894
1573
|
})(ConnManagerRequest || (ConnManagerRequest = {}));
|
|
895
1574
|
export var DisconnectRequest;
|
|
896
1575
|
(function (DisconnectRequest) {
|
|
@@ -908,33 +1587,59 @@ export var DisconnectRequest;
|
|
|
908
1587
|
if (opts.lengthDelimited !== false) {
|
|
909
1588
|
w.ldelim();
|
|
910
1589
|
}
|
|
911
|
-
}, (reader, length) => {
|
|
1590
|
+
}, (reader, length, opts = {}) => {
|
|
912
1591
|
const obj = {
|
|
913
|
-
peer:
|
|
1592
|
+
peer: uint8ArrayAlloc(0)
|
|
914
1593
|
};
|
|
915
1594
|
const end = length == null ? reader.len : reader.pos + length;
|
|
916
1595
|
while (reader.pos < end) {
|
|
917
1596
|
const tag = reader.uint32();
|
|
918
1597
|
switch (tag >>> 3) {
|
|
919
|
-
case 1:
|
|
1598
|
+
case 1: {
|
|
920
1599
|
obj.peer = reader.bytes();
|
|
921
1600
|
break;
|
|
922
|
-
|
|
1601
|
+
}
|
|
1602
|
+
default: {
|
|
923
1603
|
reader.skipType(tag & 7);
|
|
924
1604
|
break;
|
|
1605
|
+
}
|
|
925
1606
|
}
|
|
926
1607
|
}
|
|
927
1608
|
return obj;
|
|
1609
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
1610
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1611
|
+
while (reader.pos < end) {
|
|
1612
|
+
const tag = reader.uint32();
|
|
1613
|
+
switch (tag >>> 3) {
|
|
1614
|
+
case 1: {
|
|
1615
|
+
yield {
|
|
1616
|
+
field: `${prefix}.peer`,
|
|
1617
|
+
value: reader.bytes()
|
|
1618
|
+
};
|
|
1619
|
+
break;
|
|
1620
|
+
}
|
|
1621
|
+
default: {
|
|
1622
|
+
reader.skipType(tag & 7);
|
|
1623
|
+
break;
|
|
1624
|
+
}
|
|
1625
|
+
}
|
|
1626
|
+
}
|
|
928
1627
|
});
|
|
929
1628
|
}
|
|
930
1629
|
return _codec;
|
|
931
1630
|
};
|
|
932
|
-
|
|
1631
|
+
function encode(obj) {
|
|
933
1632
|
return encodeMessage(obj, DisconnectRequest.codec());
|
|
934
|
-
}
|
|
935
|
-
DisconnectRequest.
|
|
936
|
-
|
|
937
|
-
|
|
1633
|
+
}
|
|
1634
|
+
DisconnectRequest.encode = encode;
|
|
1635
|
+
function decode(buf, opts) {
|
|
1636
|
+
return decodeMessage(buf, DisconnectRequest.codec(), opts);
|
|
1637
|
+
}
|
|
1638
|
+
DisconnectRequest.decode = decode;
|
|
1639
|
+
function stream(buf, opts) {
|
|
1640
|
+
return streamMessage(buf, DisconnectRequest.codec(), opts);
|
|
1641
|
+
}
|
|
1642
|
+
DisconnectRequest.stream = stream;
|
|
938
1643
|
})(DisconnectRequest || (DisconnectRequest = {}));
|
|
939
1644
|
export var PSRequest;
|
|
940
1645
|
(function (PSRequest) {
|
|
@@ -979,37 +1684,79 @@ export var PSRequest;
|
|
|
979
1684
|
if (opts.lengthDelimited !== false) {
|
|
980
1685
|
w.ldelim();
|
|
981
1686
|
}
|
|
982
|
-
}, (reader, length) => {
|
|
1687
|
+
}, (reader, length, opts = {}) => {
|
|
983
1688
|
const obj = {};
|
|
984
1689
|
const end = length == null ? reader.len : reader.pos + length;
|
|
985
1690
|
while (reader.pos < end) {
|
|
986
1691
|
const tag = reader.uint32();
|
|
987
1692
|
switch (tag >>> 3) {
|
|
988
|
-
case 1:
|
|
1693
|
+
case 1: {
|
|
989
1694
|
obj.type = PSRequest.Type.codec().decode(reader);
|
|
990
1695
|
break;
|
|
991
|
-
|
|
1696
|
+
}
|
|
1697
|
+
case 2: {
|
|
992
1698
|
obj.topic = reader.string();
|
|
993
1699
|
break;
|
|
994
|
-
|
|
1700
|
+
}
|
|
1701
|
+
case 3: {
|
|
995
1702
|
obj.data = reader.bytes();
|
|
996
1703
|
break;
|
|
997
|
-
|
|
1704
|
+
}
|
|
1705
|
+
default: {
|
|
998
1706
|
reader.skipType(tag & 7);
|
|
999
1707
|
break;
|
|
1708
|
+
}
|
|
1000
1709
|
}
|
|
1001
1710
|
}
|
|
1002
1711
|
return obj;
|
|
1712
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
1713
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1714
|
+
while (reader.pos < end) {
|
|
1715
|
+
const tag = reader.uint32();
|
|
1716
|
+
switch (tag >>> 3) {
|
|
1717
|
+
case 1: {
|
|
1718
|
+
yield {
|
|
1719
|
+
field: `${prefix}.type`,
|
|
1720
|
+
value: PSRequest.Type.codec().decode(reader)
|
|
1721
|
+
};
|
|
1722
|
+
break;
|
|
1723
|
+
}
|
|
1724
|
+
case 2: {
|
|
1725
|
+
yield {
|
|
1726
|
+
field: `${prefix}.topic`,
|
|
1727
|
+
value: reader.string()
|
|
1728
|
+
};
|
|
1729
|
+
break;
|
|
1730
|
+
}
|
|
1731
|
+
case 3: {
|
|
1732
|
+
yield {
|
|
1733
|
+
field: `${prefix}.data`,
|
|
1734
|
+
value: reader.bytes()
|
|
1735
|
+
};
|
|
1736
|
+
break;
|
|
1737
|
+
}
|
|
1738
|
+
default: {
|
|
1739
|
+
reader.skipType(tag & 7);
|
|
1740
|
+
break;
|
|
1741
|
+
}
|
|
1742
|
+
}
|
|
1743
|
+
}
|
|
1003
1744
|
});
|
|
1004
1745
|
}
|
|
1005
1746
|
return _codec;
|
|
1006
1747
|
};
|
|
1007
|
-
|
|
1748
|
+
function encode(obj) {
|
|
1008
1749
|
return encodeMessage(obj, PSRequest.codec());
|
|
1009
|
-
}
|
|
1010
|
-
PSRequest.
|
|
1011
|
-
|
|
1012
|
-
|
|
1750
|
+
}
|
|
1751
|
+
PSRequest.encode = encode;
|
|
1752
|
+
function decode(buf, opts) {
|
|
1753
|
+
return decodeMessage(buf, PSRequest.codec(), opts);
|
|
1754
|
+
}
|
|
1755
|
+
PSRequest.decode = decode;
|
|
1756
|
+
function stream(buf, opts) {
|
|
1757
|
+
return streamMessage(buf, PSRequest.codec(), opts);
|
|
1758
|
+
}
|
|
1759
|
+
PSRequest.stream = stream;
|
|
1013
1760
|
})(PSRequest || (PSRequest = {}));
|
|
1014
1761
|
export var PSMessage;
|
|
1015
1762
|
(function (PSMessage) {
|
|
@@ -1032,7 +1779,7 @@ export var PSMessage;
|
|
|
1032
1779
|
w.uint32(26);
|
|
1033
1780
|
w.bytes(obj.seqno);
|
|
1034
1781
|
}
|
|
1035
|
-
if (obj.topicIDs != null) {
|
|
1782
|
+
if (obj.topicIDs != null && obj.topicIDs.length > 0) {
|
|
1036
1783
|
for (const value of obj.topicIDs) {
|
|
1037
1784
|
w.uint32(34);
|
|
1038
1785
|
w.string(value);
|
|
@@ -1049,7 +1796,7 @@ export var PSMessage;
|
|
|
1049
1796
|
if (opts.lengthDelimited !== false) {
|
|
1050
1797
|
w.ldelim();
|
|
1051
1798
|
}
|
|
1052
|
-
}, (reader, length) => {
|
|
1799
|
+
}, (reader, length, opts = {}) => {
|
|
1053
1800
|
const obj = {
|
|
1054
1801
|
topicIDs: []
|
|
1055
1802
|
};
|
|
@@ -1057,40 +1804,117 @@ export var PSMessage;
|
|
|
1057
1804
|
while (reader.pos < end) {
|
|
1058
1805
|
const tag = reader.uint32();
|
|
1059
1806
|
switch (tag >>> 3) {
|
|
1060
|
-
case 1:
|
|
1807
|
+
case 1: {
|
|
1061
1808
|
obj.from = reader.bytes();
|
|
1062
1809
|
break;
|
|
1063
|
-
|
|
1810
|
+
}
|
|
1811
|
+
case 2: {
|
|
1064
1812
|
obj.data = reader.bytes();
|
|
1065
1813
|
break;
|
|
1066
|
-
|
|
1814
|
+
}
|
|
1815
|
+
case 3: {
|
|
1067
1816
|
obj.seqno = reader.bytes();
|
|
1068
1817
|
break;
|
|
1069
|
-
|
|
1818
|
+
}
|
|
1819
|
+
case 4: {
|
|
1820
|
+
if (opts.limits?.topicIDs != null && obj.topicIDs.length === opts.limits.topicIDs) {
|
|
1821
|
+
throw new MaxLengthError('Decode error - repeated field "topicIDs" had too many elements');
|
|
1822
|
+
}
|
|
1070
1823
|
obj.topicIDs.push(reader.string());
|
|
1071
1824
|
break;
|
|
1072
|
-
|
|
1825
|
+
}
|
|
1826
|
+
case 5: {
|
|
1073
1827
|
obj.signature = reader.bytes();
|
|
1074
1828
|
break;
|
|
1075
|
-
|
|
1829
|
+
}
|
|
1830
|
+
case 6: {
|
|
1076
1831
|
obj.key = reader.bytes();
|
|
1077
1832
|
break;
|
|
1078
|
-
|
|
1833
|
+
}
|
|
1834
|
+
default: {
|
|
1079
1835
|
reader.skipType(tag & 7);
|
|
1080
1836
|
break;
|
|
1837
|
+
}
|
|
1081
1838
|
}
|
|
1082
1839
|
}
|
|
1083
1840
|
return obj;
|
|
1841
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
1842
|
+
const obj = {
|
|
1843
|
+
topicIDs: 0
|
|
1844
|
+
};
|
|
1845
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1846
|
+
while (reader.pos < end) {
|
|
1847
|
+
const tag = reader.uint32();
|
|
1848
|
+
switch (tag >>> 3) {
|
|
1849
|
+
case 1: {
|
|
1850
|
+
yield {
|
|
1851
|
+
field: `${prefix}.from`,
|
|
1852
|
+
value: reader.bytes()
|
|
1853
|
+
};
|
|
1854
|
+
break;
|
|
1855
|
+
}
|
|
1856
|
+
case 2: {
|
|
1857
|
+
yield {
|
|
1858
|
+
field: `${prefix}.data`,
|
|
1859
|
+
value: reader.bytes()
|
|
1860
|
+
};
|
|
1861
|
+
break;
|
|
1862
|
+
}
|
|
1863
|
+
case 3: {
|
|
1864
|
+
yield {
|
|
1865
|
+
field: `${prefix}.seqno`,
|
|
1866
|
+
value: reader.bytes()
|
|
1867
|
+
};
|
|
1868
|
+
break;
|
|
1869
|
+
}
|
|
1870
|
+
case 4: {
|
|
1871
|
+
if (opts.limits?.topicIDs != null && obj.topicIDs === opts.limits.topicIDs) {
|
|
1872
|
+
throw new MaxLengthError('Streaming decode error - repeated field "topicIDs" had too many elements');
|
|
1873
|
+
}
|
|
1874
|
+
yield {
|
|
1875
|
+
field: `${prefix}.topicIDs[]`,
|
|
1876
|
+
index: obj.topicIDs,
|
|
1877
|
+
value: reader.string()
|
|
1878
|
+
};
|
|
1879
|
+
obj.topicIDs++;
|
|
1880
|
+
break;
|
|
1881
|
+
}
|
|
1882
|
+
case 5: {
|
|
1883
|
+
yield {
|
|
1884
|
+
field: `${prefix}.signature`,
|
|
1885
|
+
value: reader.bytes()
|
|
1886
|
+
};
|
|
1887
|
+
break;
|
|
1888
|
+
}
|
|
1889
|
+
case 6: {
|
|
1890
|
+
yield {
|
|
1891
|
+
field: `${prefix}.key`,
|
|
1892
|
+
value: reader.bytes()
|
|
1893
|
+
};
|
|
1894
|
+
break;
|
|
1895
|
+
}
|
|
1896
|
+
default: {
|
|
1897
|
+
reader.skipType(tag & 7);
|
|
1898
|
+
break;
|
|
1899
|
+
}
|
|
1900
|
+
}
|
|
1901
|
+
}
|
|
1084
1902
|
});
|
|
1085
1903
|
}
|
|
1086
1904
|
return _codec;
|
|
1087
1905
|
};
|
|
1088
|
-
|
|
1906
|
+
function encode(obj) {
|
|
1089
1907
|
return encodeMessage(obj, PSMessage.codec());
|
|
1090
|
-
}
|
|
1091
|
-
PSMessage.
|
|
1092
|
-
|
|
1093
|
-
|
|
1908
|
+
}
|
|
1909
|
+
PSMessage.encode = encode;
|
|
1910
|
+
function decode(buf, opts) {
|
|
1911
|
+
return decodeMessage(buf, PSMessage.codec(), opts);
|
|
1912
|
+
}
|
|
1913
|
+
PSMessage.decode = decode;
|
|
1914
|
+
function stream(buf, opts) {
|
|
1915
|
+
return streamMessage(buf, PSMessage.codec(), opts);
|
|
1916
|
+
}
|
|
1917
|
+
PSMessage.stream = stream;
|
|
1094
1918
|
})(PSMessage || (PSMessage = {}));
|
|
1095
1919
|
export var PSResponse;
|
|
1096
1920
|
(function (PSResponse) {
|
|
@@ -1101,13 +1925,13 @@ export var PSResponse;
|
|
|
1101
1925
|
if (opts.lengthDelimited !== false) {
|
|
1102
1926
|
w.fork();
|
|
1103
1927
|
}
|
|
1104
|
-
if (obj.topics != null) {
|
|
1928
|
+
if (obj.topics != null && obj.topics.length > 0) {
|
|
1105
1929
|
for (const value of obj.topics) {
|
|
1106
1930
|
w.uint32(10);
|
|
1107
1931
|
w.string(value);
|
|
1108
1932
|
}
|
|
1109
1933
|
}
|
|
1110
|
-
if (obj.peerIDs != null) {
|
|
1934
|
+
if (obj.peerIDs != null && obj.peerIDs.length > 0) {
|
|
1111
1935
|
for (const value of obj.peerIDs) {
|
|
1112
1936
|
w.uint32(18);
|
|
1113
1937
|
w.bytes(value);
|
|
@@ -1116,7 +1940,7 @@ export var PSResponse;
|
|
|
1116
1940
|
if (opts.lengthDelimited !== false) {
|
|
1117
1941
|
w.ldelim();
|
|
1118
1942
|
}
|
|
1119
|
-
}, (reader, length) => {
|
|
1943
|
+
}, (reader, length, opts = {}) => {
|
|
1120
1944
|
const obj = {
|
|
1121
1945
|
topics: [],
|
|
1122
1946
|
peerIDs: []
|
|
@@ -1125,28 +1949,82 @@ export var PSResponse;
|
|
|
1125
1949
|
while (reader.pos < end) {
|
|
1126
1950
|
const tag = reader.uint32();
|
|
1127
1951
|
switch (tag >>> 3) {
|
|
1128
|
-
case 1:
|
|
1952
|
+
case 1: {
|
|
1953
|
+
if (opts.limits?.topics != null && obj.topics.length === opts.limits.topics) {
|
|
1954
|
+
throw new MaxLengthError('Decode error - repeated field "topics" had too many elements');
|
|
1955
|
+
}
|
|
1129
1956
|
obj.topics.push(reader.string());
|
|
1130
1957
|
break;
|
|
1131
|
-
|
|
1958
|
+
}
|
|
1959
|
+
case 2: {
|
|
1960
|
+
if (opts.limits?.peerIDs != null && obj.peerIDs.length === opts.limits.peerIDs) {
|
|
1961
|
+
throw new MaxLengthError('Decode error - repeated field "peerIDs" had too many elements');
|
|
1962
|
+
}
|
|
1132
1963
|
obj.peerIDs.push(reader.bytes());
|
|
1133
1964
|
break;
|
|
1134
|
-
|
|
1965
|
+
}
|
|
1966
|
+
default: {
|
|
1135
1967
|
reader.skipType(tag & 7);
|
|
1136
1968
|
break;
|
|
1969
|
+
}
|
|
1137
1970
|
}
|
|
1138
1971
|
}
|
|
1139
1972
|
return obj;
|
|
1973
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
1974
|
+
const obj = {
|
|
1975
|
+
topics: 0,
|
|
1976
|
+
peerIDs: 0
|
|
1977
|
+
};
|
|
1978
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1979
|
+
while (reader.pos < end) {
|
|
1980
|
+
const tag = reader.uint32();
|
|
1981
|
+
switch (tag >>> 3) {
|
|
1982
|
+
case 1: {
|
|
1983
|
+
if (opts.limits?.topics != null && obj.topics === opts.limits.topics) {
|
|
1984
|
+
throw new MaxLengthError('Streaming decode error - repeated field "topics" had too many elements');
|
|
1985
|
+
}
|
|
1986
|
+
yield {
|
|
1987
|
+
field: `${prefix}.topics[]`,
|
|
1988
|
+
index: obj.topics,
|
|
1989
|
+
value: reader.string()
|
|
1990
|
+
};
|
|
1991
|
+
obj.topics++;
|
|
1992
|
+
break;
|
|
1993
|
+
}
|
|
1994
|
+
case 2: {
|
|
1995
|
+
if (opts.limits?.peerIDs != null && obj.peerIDs === opts.limits.peerIDs) {
|
|
1996
|
+
throw new MaxLengthError('Streaming decode error - repeated field "peerIDs" had too many elements');
|
|
1997
|
+
}
|
|
1998
|
+
yield {
|
|
1999
|
+
field: `${prefix}.peerIDs[]`,
|
|
2000
|
+
index: obj.peerIDs,
|
|
2001
|
+
value: reader.bytes()
|
|
2002
|
+
};
|
|
2003
|
+
obj.peerIDs++;
|
|
2004
|
+
break;
|
|
2005
|
+
}
|
|
2006
|
+
default: {
|
|
2007
|
+
reader.skipType(tag & 7);
|
|
2008
|
+
break;
|
|
2009
|
+
}
|
|
2010
|
+
}
|
|
2011
|
+
}
|
|
1140
2012
|
});
|
|
1141
2013
|
}
|
|
1142
2014
|
return _codec;
|
|
1143
2015
|
};
|
|
1144
|
-
|
|
2016
|
+
function encode(obj) {
|
|
1145
2017
|
return encodeMessage(obj, PSResponse.codec());
|
|
1146
|
-
}
|
|
1147
|
-
PSResponse.
|
|
1148
|
-
|
|
1149
|
-
|
|
2018
|
+
}
|
|
2019
|
+
PSResponse.encode = encode;
|
|
2020
|
+
function decode(buf, opts) {
|
|
2021
|
+
return decodeMessage(buf, PSResponse.codec(), opts);
|
|
2022
|
+
}
|
|
2023
|
+
PSResponse.decode = decode;
|
|
2024
|
+
function stream(buf, opts) {
|
|
2025
|
+
return streamMessage(buf, PSResponse.codec(), opts);
|
|
2026
|
+
}
|
|
2027
|
+
PSResponse.stream = stream;
|
|
1150
2028
|
})(PSResponse || (PSResponse = {}));
|
|
1151
2029
|
export var PeerstoreRequest;
|
|
1152
2030
|
(function (PeerstoreRequest) {
|
|
@@ -1182,7 +2060,7 @@ export var PeerstoreRequest;
|
|
|
1182
2060
|
w.uint32(18);
|
|
1183
2061
|
w.bytes(obj.id);
|
|
1184
2062
|
}
|
|
1185
|
-
if (obj.protos != null) {
|
|
2063
|
+
if (obj.protos != null && obj.protos.length > 0) {
|
|
1186
2064
|
for (const value of obj.protos) {
|
|
1187
2065
|
w.uint32(26);
|
|
1188
2066
|
w.string(value);
|
|
@@ -1191,7 +2069,7 @@ export var PeerstoreRequest;
|
|
|
1191
2069
|
if (opts.lengthDelimited !== false) {
|
|
1192
2070
|
w.ldelim();
|
|
1193
2071
|
}
|
|
1194
|
-
}, (reader, length) => {
|
|
2072
|
+
}, (reader, length, opts = {}) => {
|
|
1195
2073
|
const obj = {
|
|
1196
2074
|
protos: []
|
|
1197
2075
|
};
|
|
@@ -1199,31 +2077,84 @@ export var PeerstoreRequest;
|
|
|
1199
2077
|
while (reader.pos < end) {
|
|
1200
2078
|
const tag = reader.uint32();
|
|
1201
2079
|
switch (tag >>> 3) {
|
|
1202
|
-
case 1:
|
|
2080
|
+
case 1: {
|
|
1203
2081
|
obj.type = PeerstoreRequest.Type.codec().decode(reader);
|
|
1204
2082
|
break;
|
|
1205
|
-
|
|
2083
|
+
}
|
|
2084
|
+
case 2: {
|
|
1206
2085
|
obj.id = reader.bytes();
|
|
1207
2086
|
break;
|
|
1208
|
-
|
|
2087
|
+
}
|
|
2088
|
+
case 3: {
|
|
2089
|
+
if (opts.limits?.protos != null && obj.protos.length === opts.limits.protos) {
|
|
2090
|
+
throw new MaxLengthError('Decode error - repeated field "protos" had too many elements');
|
|
2091
|
+
}
|
|
1209
2092
|
obj.protos.push(reader.string());
|
|
1210
2093
|
break;
|
|
1211
|
-
|
|
2094
|
+
}
|
|
2095
|
+
default: {
|
|
1212
2096
|
reader.skipType(tag & 7);
|
|
1213
2097
|
break;
|
|
2098
|
+
}
|
|
1214
2099
|
}
|
|
1215
2100
|
}
|
|
1216
2101
|
return obj;
|
|
2102
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
2103
|
+
const obj = {
|
|
2104
|
+
protos: 0
|
|
2105
|
+
};
|
|
2106
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
2107
|
+
while (reader.pos < end) {
|
|
2108
|
+
const tag = reader.uint32();
|
|
2109
|
+
switch (tag >>> 3) {
|
|
2110
|
+
case 1: {
|
|
2111
|
+
yield {
|
|
2112
|
+
field: `${prefix}.type`,
|
|
2113
|
+
value: PeerstoreRequest.Type.codec().decode(reader)
|
|
2114
|
+
};
|
|
2115
|
+
break;
|
|
2116
|
+
}
|
|
2117
|
+
case 2: {
|
|
2118
|
+
yield {
|
|
2119
|
+
field: `${prefix}.id`,
|
|
2120
|
+
value: reader.bytes()
|
|
2121
|
+
};
|
|
2122
|
+
break;
|
|
2123
|
+
}
|
|
2124
|
+
case 3: {
|
|
2125
|
+
if (opts.limits?.protos != null && obj.protos === opts.limits.protos) {
|
|
2126
|
+
throw new MaxLengthError('Streaming decode error - repeated field "protos" had too many elements');
|
|
2127
|
+
}
|
|
2128
|
+
yield {
|
|
2129
|
+
field: `${prefix}.protos[]`,
|
|
2130
|
+
index: obj.protos,
|
|
2131
|
+
value: reader.string()
|
|
2132
|
+
};
|
|
2133
|
+
obj.protos++;
|
|
2134
|
+
break;
|
|
2135
|
+
}
|
|
2136
|
+
default: {
|
|
2137
|
+
reader.skipType(tag & 7);
|
|
2138
|
+
break;
|
|
2139
|
+
}
|
|
2140
|
+
}
|
|
2141
|
+
}
|
|
1217
2142
|
});
|
|
1218
2143
|
}
|
|
1219
2144
|
return _codec;
|
|
1220
2145
|
};
|
|
1221
|
-
|
|
2146
|
+
function encode(obj) {
|
|
1222
2147
|
return encodeMessage(obj, PeerstoreRequest.codec());
|
|
1223
|
-
}
|
|
1224
|
-
PeerstoreRequest.
|
|
1225
|
-
|
|
1226
|
-
|
|
2148
|
+
}
|
|
2149
|
+
PeerstoreRequest.encode = encode;
|
|
2150
|
+
function decode(buf, opts) {
|
|
2151
|
+
return decodeMessage(buf, PeerstoreRequest.codec(), opts);
|
|
2152
|
+
}
|
|
2153
|
+
PeerstoreRequest.decode = decode;
|
|
2154
|
+
function stream(buf, opts) {
|
|
2155
|
+
return streamMessage(buf, PeerstoreRequest.codec(), opts);
|
|
2156
|
+
}
|
|
2157
|
+
PeerstoreRequest.stream = stream;
|
|
1227
2158
|
})(PeerstoreRequest || (PeerstoreRequest = {}));
|
|
1228
2159
|
export var PeerstoreResponse;
|
|
1229
2160
|
(function (PeerstoreResponse) {
|
|
@@ -1238,7 +2169,7 @@ export var PeerstoreResponse;
|
|
|
1238
2169
|
w.uint32(10);
|
|
1239
2170
|
PeerInfo.codec().encode(obj.peer, w);
|
|
1240
2171
|
}
|
|
1241
|
-
if (obj.protos != null) {
|
|
2172
|
+
if (obj.protos != null && obj.protos.length > 0) {
|
|
1242
2173
|
for (const value of obj.protos) {
|
|
1243
2174
|
w.uint32(18);
|
|
1244
2175
|
w.string(value);
|
|
@@ -1247,7 +2178,7 @@ export var PeerstoreResponse;
|
|
|
1247
2178
|
if (opts.lengthDelimited !== false) {
|
|
1248
2179
|
w.ldelim();
|
|
1249
2180
|
}
|
|
1250
|
-
}, (reader, length) => {
|
|
2181
|
+
}, (reader, length, opts = {}) => {
|
|
1251
2182
|
const obj = {
|
|
1252
2183
|
protos: []
|
|
1253
2184
|
};
|
|
@@ -1255,27 +2186,73 @@ export var PeerstoreResponse;
|
|
|
1255
2186
|
while (reader.pos < end) {
|
|
1256
2187
|
const tag = reader.uint32();
|
|
1257
2188
|
switch (tag >>> 3) {
|
|
1258
|
-
case 1:
|
|
1259
|
-
obj.peer = PeerInfo.codec().decode(reader, reader.uint32()
|
|
1260
|
-
|
|
1261
|
-
|
|
2189
|
+
case 1: {
|
|
2190
|
+
obj.peer = PeerInfo.codec().decode(reader, reader.uint32(), {
|
|
2191
|
+
limits: opts.limits?.peer
|
|
2192
|
+
});
|
|
2193
|
+
break;
|
|
2194
|
+
}
|
|
2195
|
+
case 2: {
|
|
2196
|
+
if (opts.limits?.protos != null && obj.protos.length === opts.limits.protos) {
|
|
2197
|
+
throw new MaxLengthError('Decode error - repeated field "protos" had too many elements');
|
|
2198
|
+
}
|
|
1262
2199
|
obj.protos.push(reader.string());
|
|
1263
2200
|
break;
|
|
1264
|
-
|
|
2201
|
+
}
|
|
2202
|
+
default: {
|
|
1265
2203
|
reader.skipType(tag & 7);
|
|
1266
2204
|
break;
|
|
2205
|
+
}
|
|
1267
2206
|
}
|
|
1268
2207
|
}
|
|
1269
2208
|
return obj;
|
|
2209
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
2210
|
+
const obj = {
|
|
2211
|
+
protos: 0
|
|
2212
|
+
};
|
|
2213
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
2214
|
+
while (reader.pos < end) {
|
|
2215
|
+
const tag = reader.uint32();
|
|
2216
|
+
switch (tag >>> 3) {
|
|
2217
|
+
case 1: {
|
|
2218
|
+
yield* PeerInfo.codec().stream(reader, reader.uint32(), `${prefix}.peer`, {
|
|
2219
|
+
limits: opts.limits?.peer
|
|
2220
|
+
});
|
|
2221
|
+
break;
|
|
2222
|
+
}
|
|
2223
|
+
case 2: {
|
|
2224
|
+
if (opts.limits?.protos != null && obj.protos === opts.limits.protos) {
|
|
2225
|
+
throw new MaxLengthError('Streaming decode error - repeated field "protos" had too many elements');
|
|
2226
|
+
}
|
|
2227
|
+
yield {
|
|
2228
|
+
field: `${prefix}.protos[]`,
|
|
2229
|
+
index: obj.protos,
|
|
2230
|
+
value: reader.string()
|
|
2231
|
+
};
|
|
2232
|
+
obj.protos++;
|
|
2233
|
+
break;
|
|
2234
|
+
}
|
|
2235
|
+
default: {
|
|
2236
|
+
reader.skipType(tag & 7);
|
|
2237
|
+
break;
|
|
2238
|
+
}
|
|
2239
|
+
}
|
|
2240
|
+
}
|
|
1270
2241
|
});
|
|
1271
2242
|
}
|
|
1272
2243
|
return _codec;
|
|
1273
2244
|
};
|
|
1274
|
-
|
|
2245
|
+
function encode(obj) {
|
|
1275
2246
|
return encodeMessage(obj, PeerstoreResponse.codec());
|
|
1276
|
-
}
|
|
1277
|
-
PeerstoreResponse.
|
|
1278
|
-
|
|
1279
|
-
|
|
2247
|
+
}
|
|
2248
|
+
PeerstoreResponse.encode = encode;
|
|
2249
|
+
function decode(buf, opts) {
|
|
2250
|
+
return decodeMessage(buf, PeerstoreResponse.codec(), opts);
|
|
2251
|
+
}
|
|
2252
|
+
PeerstoreResponse.decode = decode;
|
|
2253
|
+
function stream(buf, opts) {
|
|
2254
|
+
return streamMessage(buf, PeerstoreResponse.codec(), opts);
|
|
2255
|
+
}
|
|
2256
|
+
PeerstoreResponse.stream = stream;
|
|
1280
2257
|
})(PeerstoreResponse || (PeerstoreResponse = {}));
|
|
1281
2258
|
//# sourceMappingURL=index.js.map
|