@libp2p/daemon-protocol 2.0.1 → 2.0.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/src/index.d.ts +26 -26
- package/dist/src/index.d.ts.map +1 -1
- package/dist/src/index.js +1093 -101
- package/dist/src/index.js.map +1 -1
- package/package.json +4 -4
- package/src/index.ts +1325 -133
package/dist/src/index.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
/* eslint-disable import/export */
|
|
2
2
|
/* eslint-disable @typescript-eslint/no-namespace */
|
|
3
|
-
import { enumeration, encodeMessage, decodeMessage, message
|
|
3
|
+
import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime';
|
|
4
4
|
export var Request;
|
|
5
5
|
(function (Request) {
|
|
6
6
|
let Type;
|
|
@@ -34,18 +34,100 @@ export var Request;
|
|
|
34
34
|
return enumeration(__TypeValues);
|
|
35
35
|
};
|
|
36
36
|
})(Type = Request.Type || (Request.Type = {}));
|
|
37
|
+
let _codec;
|
|
37
38
|
Request.codec = () => {
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
39
|
+
if (_codec == null) {
|
|
40
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
41
|
+
if (opts.lengthDelimited !== false) {
|
|
42
|
+
writer.fork();
|
|
43
|
+
}
|
|
44
|
+
if (obj.type != null) {
|
|
45
|
+
writer.uint32(8);
|
|
46
|
+
Request.Type.codec().encode(obj.type, writer);
|
|
47
|
+
}
|
|
48
|
+
else {
|
|
49
|
+
throw new Error('Protocol error: required field "type" was not found in object');
|
|
50
|
+
}
|
|
51
|
+
if (obj.connect != null) {
|
|
52
|
+
writer.uint32(18);
|
|
53
|
+
ConnectRequest.codec().encode(obj.connect, writer);
|
|
54
|
+
}
|
|
55
|
+
if (obj.streamOpen != null) {
|
|
56
|
+
writer.uint32(26);
|
|
57
|
+
StreamOpenRequest.codec().encode(obj.streamOpen, writer);
|
|
58
|
+
}
|
|
59
|
+
if (obj.streamHandler != null) {
|
|
60
|
+
writer.uint32(34);
|
|
61
|
+
StreamHandlerRequest.codec().encode(obj.streamHandler, writer);
|
|
62
|
+
}
|
|
63
|
+
if (obj.dht != null) {
|
|
64
|
+
writer.uint32(42);
|
|
65
|
+
DHTRequest.codec().encode(obj.dht, writer);
|
|
66
|
+
}
|
|
67
|
+
if (obj.connManager != null) {
|
|
68
|
+
writer.uint32(50);
|
|
69
|
+
ConnManagerRequest.codec().encode(obj.connManager, writer);
|
|
70
|
+
}
|
|
71
|
+
if (obj.disconnect != null) {
|
|
72
|
+
writer.uint32(58);
|
|
73
|
+
DisconnectRequest.codec().encode(obj.disconnect, writer);
|
|
74
|
+
}
|
|
75
|
+
if (obj.pubsub != null) {
|
|
76
|
+
writer.uint32(66);
|
|
77
|
+
PSRequest.codec().encode(obj.pubsub, writer);
|
|
78
|
+
}
|
|
79
|
+
if (obj.peerStore != null) {
|
|
80
|
+
writer.uint32(74);
|
|
81
|
+
PeerstoreRequest.codec().encode(obj.peerStore, writer);
|
|
82
|
+
}
|
|
83
|
+
if (opts.lengthDelimited !== false) {
|
|
84
|
+
writer.ldelim();
|
|
85
|
+
}
|
|
86
|
+
}, (reader, length) => {
|
|
87
|
+
const obj = {};
|
|
88
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
89
|
+
while (reader.pos < end) {
|
|
90
|
+
const tag = reader.uint32();
|
|
91
|
+
switch (tag >>> 3) {
|
|
92
|
+
case 1:
|
|
93
|
+
obj.type = Request.Type.codec().decode(reader);
|
|
94
|
+
break;
|
|
95
|
+
case 2:
|
|
96
|
+
obj.connect = ConnectRequest.codec().decode(reader, reader.uint32());
|
|
97
|
+
break;
|
|
98
|
+
case 3:
|
|
99
|
+
obj.streamOpen = StreamOpenRequest.codec().decode(reader, reader.uint32());
|
|
100
|
+
break;
|
|
101
|
+
case 4:
|
|
102
|
+
obj.streamHandler = StreamHandlerRequest.codec().decode(reader, reader.uint32());
|
|
103
|
+
break;
|
|
104
|
+
case 5:
|
|
105
|
+
obj.dht = DHTRequest.codec().decode(reader, reader.uint32());
|
|
106
|
+
break;
|
|
107
|
+
case 6:
|
|
108
|
+
obj.connManager = ConnManagerRequest.codec().decode(reader, reader.uint32());
|
|
109
|
+
break;
|
|
110
|
+
case 7:
|
|
111
|
+
obj.disconnect = DisconnectRequest.codec().decode(reader, reader.uint32());
|
|
112
|
+
break;
|
|
113
|
+
case 8:
|
|
114
|
+
obj.pubsub = PSRequest.codec().decode(reader, reader.uint32());
|
|
115
|
+
break;
|
|
116
|
+
case 9:
|
|
117
|
+
obj.peerStore = PeerstoreRequest.codec().decode(reader, reader.uint32());
|
|
118
|
+
break;
|
|
119
|
+
default:
|
|
120
|
+
reader.skipType(tag & 7);
|
|
121
|
+
break;
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
if (obj.type == null) {
|
|
125
|
+
throw new Error('Protocol error: value for required field "type" was not found in protobuf');
|
|
126
|
+
}
|
|
127
|
+
return obj;
|
|
128
|
+
});
|
|
129
|
+
}
|
|
130
|
+
return _codec;
|
|
49
131
|
};
|
|
50
132
|
Request.encode = (obj) => {
|
|
51
133
|
return encodeMessage(obj, Request.codec());
|
|
@@ -71,17 +153,103 @@ export var Response;
|
|
|
71
153
|
return enumeration(__TypeValues);
|
|
72
154
|
};
|
|
73
155
|
})(Type = Response.Type || (Response.Type = {}));
|
|
156
|
+
let _codec;
|
|
74
157
|
Response.codec = () => {
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
158
|
+
if (_codec == null) {
|
|
159
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
160
|
+
if (opts.lengthDelimited !== false) {
|
|
161
|
+
writer.fork();
|
|
162
|
+
}
|
|
163
|
+
if (obj.type != null) {
|
|
164
|
+
writer.uint32(8);
|
|
165
|
+
Response.Type.codec().encode(obj.type, writer);
|
|
166
|
+
}
|
|
167
|
+
else {
|
|
168
|
+
throw new Error('Protocol error: required field "type" was not found in object');
|
|
169
|
+
}
|
|
170
|
+
if (obj.error != null) {
|
|
171
|
+
writer.uint32(18);
|
|
172
|
+
ErrorResponse.codec().encode(obj.error, writer);
|
|
173
|
+
}
|
|
174
|
+
if (obj.streamInfo != null) {
|
|
175
|
+
writer.uint32(26);
|
|
176
|
+
StreamInfo.codec().encode(obj.streamInfo, writer);
|
|
177
|
+
}
|
|
178
|
+
if (obj.identify != null) {
|
|
179
|
+
writer.uint32(34);
|
|
180
|
+
IdentifyResponse.codec().encode(obj.identify, writer);
|
|
181
|
+
}
|
|
182
|
+
if (obj.dht != null) {
|
|
183
|
+
writer.uint32(42);
|
|
184
|
+
DHTResponse.codec().encode(obj.dht, writer);
|
|
185
|
+
}
|
|
186
|
+
if (obj.peers != null) {
|
|
187
|
+
for (const value of obj.peers) {
|
|
188
|
+
writer.uint32(50);
|
|
189
|
+
PeerInfo.codec().encode(value, writer);
|
|
190
|
+
}
|
|
191
|
+
}
|
|
192
|
+
else {
|
|
193
|
+
throw new Error('Protocol error: required field "peers" was not found in object');
|
|
194
|
+
}
|
|
195
|
+
if (obj.pubsub != null) {
|
|
196
|
+
writer.uint32(58);
|
|
197
|
+
PSResponse.codec().encode(obj.pubsub, writer);
|
|
198
|
+
}
|
|
199
|
+
if (obj.peerStore != null) {
|
|
200
|
+
writer.uint32(66);
|
|
201
|
+
PeerstoreResponse.codec().encode(obj.peerStore, writer);
|
|
202
|
+
}
|
|
203
|
+
if (opts.lengthDelimited !== false) {
|
|
204
|
+
writer.ldelim();
|
|
205
|
+
}
|
|
206
|
+
}, (reader, length) => {
|
|
207
|
+
const obj = {};
|
|
208
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
209
|
+
while (reader.pos < end) {
|
|
210
|
+
const tag = reader.uint32();
|
|
211
|
+
switch (tag >>> 3) {
|
|
212
|
+
case 1:
|
|
213
|
+
obj.type = Response.Type.codec().decode(reader);
|
|
214
|
+
break;
|
|
215
|
+
case 2:
|
|
216
|
+
obj.error = ErrorResponse.codec().decode(reader, reader.uint32());
|
|
217
|
+
break;
|
|
218
|
+
case 3:
|
|
219
|
+
obj.streamInfo = StreamInfo.codec().decode(reader, reader.uint32());
|
|
220
|
+
break;
|
|
221
|
+
case 4:
|
|
222
|
+
obj.identify = IdentifyResponse.codec().decode(reader, reader.uint32());
|
|
223
|
+
break;
|
|
224
|
+
case 5:
|
|
225
|
+
obj.dht = DHTResponse.codec().decode(reader, reader.uint32());
|
|
226
|
+
break;
|
|
227
|
+
case 6:
|
|
228
|
+
obj.peers = obj.peers ?? [];
|
|
229
|
+
obj.peers.push(PeerInfo.codec().decode(reader, reader.uint32()));
|
|
230
|
+
break;
|
|
231
|
+
case 7:
|
|
232
|
+
obj.pubsub = PSResponse.codec().decode(reader, reader.uint32());
|
|
233
|
+
break;
|
|
234
|
+
case 8:
|
|
235
|
+
obj.peerStore = PeerstoreResponse.codec().decode(reader, reader.uint32());
|
|
236
|
+
break;
|
|
237
|
+
default:
|
|
238
|
+
reader.skipType(tag & 7);
|
|
239
|
+
break;
|
|
240
|
+
}
|
|
241
|
+
}
|
|
242
|
+
obj.peers = obj.peers ?? [];
|
|
243
|
+
if (obj.type == null) {
|
|
244
|
+
throw new Error('Protocol error: value for required field "type" was not found in protobuf');
|
|
245
|
+
}
|
|
246
|
+
if (obj.peers == null) {
|
|
247
|
+
throw new Error('Protocol error: value for required field "peers" was not found in protobuf');
|
|
248
|
+
}
|
|
249
|
+
return obj;
|
|
250
|
+
});
|
|
251
|
+
}
|
|
252
|
+
return _codec;
|
|
85
253
|
};
|
|
86
254
|
Response.encode = (obj) => {
|
|
87
255
|
return encodeMessage(obj, Response.codec());
|
|
@@ -92,11 +260,61 @@ export var Response;
|
|
|
92
260
|
})(Response || (Response = {}));
|
|
93
261
|
export var IdentifyResponse;
|
|
94
262
|
(function (IdentifyResponse) {
|
|
263
|
+
let _codec;
|
|
95
264
|
IdentifyResponse.codec = () => {
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
265
|
+
if (_codec == null) {
|
|
266
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
267
|
+
if (opts.lengthDelimited !== false) {
|
|
268
|
+
writer.fork();
|
|
269
|
+
}
|
|
270
|
+
if (obj.id != null) {
|
|
271
|
+
writer.uint32(10);
|
|
272
|
+
writer.bytes(obj.id);
|
|
273
|
+
}
|
|
274
|
+
else {
|
|
275
|
+
throw new Error('Protocol error: required field "id" was not found in object');
|
|
276
|
+
}
|
|
277
|
+
if (obj.addrs != null) {
|
|
278
|
+
for (const value of obj.addrs) {
|
|
279
|
+
writer.uint32(18);
|
|
280
|
+
writer.bytes(value);
|
|
281
|
+
}
|
|
282
|
+
}
|
|
283
|
+
else {
|
|
284
|
+
throw new Error('Protocol error: required field "addrs" was not found in object');
|
|
285
|
+
}
|
|
286
|
+
if (opts.lengthDelimited !== false) {
|
|
287
|
+
writer.ldelim();
|
|
288
|
+
}
|
|
289
|
+
}, (reader, length) => {
|
|
290
|
+
const obj = {};
|
|
291
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
292
|
+
while (reader.pos < end) {
|
|
293
|
+
const tag = reader.uint32();
|
|
294
|
+
switch (tag >>> 3) {
|
|
295
|
+
case 1:
|
|
296
|
+
obj.id = reader.bytes();
|
|
297
|
+
break;
|
|
298
|
+
case 2:
|
|
299
|
+
obj.addrs = obj.addrs ?? [];
|
|
300
|
+
obj.addrs.push(reader.bytes());
|
|
301
|
+
break;
|
|
302
|
+
default:
|
|
303
|
+
reader.skipType(tag & 7);
|
|
304
|
+
break;
|
|
305
|
+
}
|
|
306
|
+
}
|
|
307
|
+
obj.addrs = obj.addrs ?? [];
|
|
308
|
+
if (obj.id == null) {
|
|
309
|
+
throw new Error('Protocol error: value for required field "id" was not found in protobuf');
|
|
310
|
+
}
|
|
311
|
+
if (obj.addrs == null) {
|
|
312
|
+
throw new Error('Protocol error: value for required field "addrs" was not found in protobuf');
|
|
313
|
+
}
|
|
314
|
+
return obj;
|
|
315
|
+
});
|
|
316
|
+
}
|
|
317
|
+
return _codec;
|
|
100
318
|
};
|
|
101
319
|
IdentifyResponse.encode = (obj) => {
|
|
102
320
|
return encodeMessage(obj, IdentifyResponse.codec());
|
|
@@ -107,12 +325,68 @@ export var IdentifyResponse;
|
|
|
107
325
|
})(IdentifyResponse || (IdentifyResponse = {}));
|
|
108
326
|
export var ConnectRequest;
|
|
109
327
|
(function (ConnectRequest) {
|
|
328
|
+
let _codec;
|
|
110
329
|
ConnectRequest.codec = () => {
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
330
|
+
if (_codec == null) {
|
|
331
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
332
|
+
if (opts.lengthDelimited !== false) {
|
|
333
|
+
writer.fork();
|
|
334
|
+
}
|
|
335
|
+
if (obj.peer != null) {
|
|
336
|
+
writer.uint32(10);
|
|
337
|
+
writer.bytes(obj.peer);
|
|
338
|
+
}
|
|
339
|
+
else {
|
|
340
|
+
throw new Error('Protocol error: required field "peer" was not found in object');
|
|
341
|
+
}
|
|
342
|
+
if (obj.addrs != null) {
|
|
343
|
+
for (const value of obj.addrs) {
|
|
344
|
+
writer.uint32(18);
|
|
345
|
+
writer.bytes(value);
|
|
346
|
+
}
|
|
347
|
+
}
|
|
348
|
+
else {
|
|
349
|
+
throw new Error('Protocol error: required field "addrs" was not found in object');
|
|
350
|
+
}
|
|
351
|
+
if (obj.timeout != null) {
|
|
352
|
+
writer.uint32(24);
|
|
353
|
+
writer.int64(obj.timeout);
|
|
354
|
+
}
|
|
355
|
+
if (opts.lengthDelimited !== false) {
|
|
356
|
+
writer.ldelim();
|
|
357
|
+
}
|
|
358
|
+
}, (reader, length) => {
|
|
359
|
+
const obj = {};
|
|
360
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
361
|
+
while (reader.pos < end) {
|
|
362
|
+
const tag = reader.uint32();
|
|
363
|
+
switch (tag >>> 3) {
|
|
364
|
+
case 1:
|
|
365
|
+
obj.peer = reader.bytes();
|
|
366
|
+
break;
|
|
367
|
+
case 2:
|
|
368
|
+
obj.addrs = obj.addrs ?? [];
|
|
369
|
+
obj.addrs.push(reader.bytes());
|
|
370
|
+
break;
|
|
371
|
+
case 3:
|
|
372
|
+
obj.timeout = reader.int64();
|
|
373
|
+
break;
|
|
374
|
+
default:
|
|
375
|
+
reader.skipType(tag & 7);
|
|
376
|
+
break;
|
|
377
|
+
}
|
|
378
|
+
}
|
|
379
|
+
obj.addrs = obj.addrs ?? [];
|
|
380
|
+
if (obj.peer == null) {
|
|
381
|
+
throw new Error('Protocol error: value for required field "peer" was not found in protobuf');
|
|
382
|
+
}
|
|
383
|
+
if (obj.addrs == null) {
|
|
384
|
+
throw new Error('Protocol error: value for required field "addrs" was not found in protobuf');
|
|
385
|
+
}
|
|
386
|
+
return obj;
|
|
387
|
+
});
|
|
388
|
+
}
|
|
389
|
+
return _codec;
|
|
116
390
|
};
|
|
117
391
|
ConnectRequest.encode = (obj) => {
|
|
118
392
|
return encodeMessage(obj, ConnectRequest.codec());
|
|
@@ -123,12 +397,68 @@ export var ConnectRequest;
|
|
|
123
397
|
})(ConnectRequest || (ConnectRequest = {}));
|
|
124
398
|
export var StreamOpenRequest;
|
|
125
399
|
(function (StreamOpenRequest) {
|
|
400
|
+
let _codec;
|
|
126
401
|
StreamOpenRequest.codec = () => {
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
402
|
+
if (_codec == null) {
|
|
403
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
404
|
+
if (opts.lengthDelimited !== false) {
|
|
405
|
+
writer.fork();
|
|
406
|
+
}
|
|
407
|
+
if (obj.peer != null) {
|
|
408
|
+
writer.uint32(10);
|
|
409
|
+
writer.bytes(obj.peer);
|
|
410
|
+
}
|
|
411
|
+
else {
|
|
412
|
+
throw new Error('Protocol error: required field "peer" was not found in object');
|
|
413
|
+
}
|
|
414
|
+
if (obj.proto != null) {
|
|
415
|
+
for (const value of obj.proto) {
|
|
416
|
+
writer.uint32(18);
|
|
417
|
+
writer.string(value);
|
|
418
|
+
}
|
|
419
|
+
}
|
|
420
|
+
else {
|
|
421
|
+
throw new Error('Protocol error: required field "proto" was not found in object');
|
|
422
|
+
}
|
|
423
|
+
if (obj.timeout != null) {
|
|
424
|
+
writer.uint32(24);
|
|
425
|
+
writer.int64(obj.timeout);
|
|
426
|
+
}
|
|
427
|
+
if (opts.lengthDelimited !== false) {
|
|
428
|
+
writer.ldelim();
|
|
429
|
+
}
|
|
430
|
+
}, (reader, length) => {
|
|
431
|
+
const obj = {};
|
|
432
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
433
|
+
while (reader.pos < end) {
|
|
434
|
+
const tag = reader.uint32();
|
|
435
|
+
switch (tag >>> 3) {
|
|
436
|
+
case 1:
|
|
437
|
+
obj.peer = reader.bytes();
|
|
438
|
+
break;
|
|
439
|
+
case 2:
|
|
440
|
+
obj.proto = obj.proto ?? [];
|
|
441
|
+
obj.proto.push(reader.string());
|
|
442
|
+
break;
|
|
443
|
+
case 3:
|
|
444
|
+
obj.timeout = reader.int64();
|
|
445
|
+
break;
|
|
446
|
+
default:
|
|
447
|
+
reader.skipType(tag & 7);
|
|
448
|
+
break;
|
|
449
|
+
}
|
|
450
|
+
}
|
|
451
|
+
obj.proto = obj.proto ?? [];
|
|
452
|
+
if (obj.peer == null) {
|
|
453
|
+
throw new Error('Protocol error: value for required field "peer" was not found in protobuf');
|
|
454
|
+
}
|
|
455
|
+
if (obj.proto == null) {
|
|
456
|
+
throw new Error('Protocol error: value for required field "proto" was not found in protobuf');
|
|
457
|
+
}
|
|
458
|
+
return obj;
|
|
459
|
+
});
|
|
460
|
+
}
|
|
461
|
+
return _codec;
|
|
132
462
|
};
|
|
133
463
|
StreamOpenRequest.encode = (obj) => {
|
|
134
464
|
return encodeMessage(obj, StreamOpenRequest.codec());
|
|
@@ -139,11 +469,61 @@ export var StreamOpenRequest;
|
|
|
139
469
|
})(StreamOpenRequest || (StreamOpenRequest = {}));
|
|
140
470
|
export var StreamHandlerRequest;
|
|
141
471
|
(function (StreamHandlerRequest) {
|
|
472
|
+
let _codec;
|
|
142
473
|
StreamHandlerRequest.codec = () => {
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
474
|
+
if (_codec == null) {
|
|
475
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
476
|
+
if (opts.lengthDelimited !== false) {
|
|
477
|
+
writer.fork();
|
|
478
|
+
}
|
|
479
|
+
if (obj.addr != null) {
|
|
480
|
+
writer.uint32(10);
|
|
481
|
+
writer.bytes(obj.addr);
|
|
482
|
+
}
|
|
483
|
+
else {
|
|
484
|
+
throw new Error('Protocol error: required field "addr" was not found in object');
|
|
485
|
+
}
|
|
486
|
+
if (obj.proto != null) {
|
|
487
|
+
for (const value of obj.proto) {
|
|
488
|
+
writer.uint32(18);
|
|
489
|
+
writer.string(value);
|
|
490
|
+
}
|
|
491
|
+
}
|
|
492
|
+
else {
|
|
493
|
+
throw new Error('Protocol error: required field "proto" was not found in object');
|
|
494
|
+
}
|
|
495
|
+
if (opts.lengthDelimited !== false) {
|
|
496
|
+
writer.ldelim();
|
|
497
|
+
}
|
|
498
|
+
}, (reader, length) => {
|
|
499
|
+
const obj = {};
|
|
500
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
501
|
+
while (reader.pos < end) {
|
|
502
|
+
const tag = reader.uint32();
|
|
503
|
+
switch (tag >>> 3) {
|
|
504
|
+
case 1:
|
|
505
|
+
obj.addr = reader.bytes();
|
|
506
|
+
break;
|
|
507
|
+
case 2:
|
|
508
|
+
obj.proto = obj.proto ?? [];
|
|
509
|
+
obj.proto.push(reader.string());
|
|
510
|
+
break;
|
|
511
|
+
default:
|
|
512
|
+
reader.skipType(tag & 7);
|
|
513
|
+
break;
|
|
514
|
+
}
|
|
515
|
+
}
|
|
516
|
+
obj.proto = obj.proto ?? [];
|
|
517
|
+
if (obj.addr == null) {
|
|
518
|
+
throw new Error('Protocol error: value for required field "addr" was not found in protobuf');
|
|
519
|
+
}
|
|
520
|
+
if (obj.proto == null) {
|
|
521
|
+
throw new Error('Protocol error: value for required field "proto" was not found in protobuf');
|
|
522
|
+
}
|
|
523
|
+
return obj;
|
|
524
|
+
});
|
|
525
|
+
}
|
|
526
|
+
return _codec;
|
|
147
527
|
};
|
|
148
528
|
StreamHandlerRequest.encode = (obj) => {
|
|
149
529
|
return encodeMessage(obj, StreamHandlerRequest.codec());
|
|
@@ -154,10 +534,44 @@ export var StreamHandlerRequest;
|
|
|
154
534
|
})(StreamHandlerRequest || (StreamHandlerRequest = {}));
|
|
155
535
|
export var ErrorResponse;
|
|
156
536
|
(function (ErrorResponse) {
|
|
537
|
+
let _codec;
|
|
157
538
|
ErrorResponse.codec = () => {
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
539
|
+
if (_codec == null) {
|
|
540
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
541
|
+
if (opts.lengthDelimited !== false) {
|
|
542
|
+
writer.fork();
|
|
543
|
+
}
|
|
544
|
+
if (obj.msg != null) {
|
|
545
|
+
writer.uint32(10);
|
|
546
|
+
writer.string(obj.msg);
|
|
547
|
+
}
|
|
548
|
+
else {
|
|
549
|
+
throw new Error('Protocol error: required field "msg" was not found in object');
|
|
550
|
+
}
|
|
551
|
+
if (opts.lengthDelimited !== false) {
|
|
552
|
+
writer.ldelim();
|
|
553
|
+
}
|
|
554
|
+
}, (reader, length) => {
|
|
555
|
+
const obj = {};
|
|
556
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
557
|
+
while (reader.pos < end) {
|
|
558
|
+
const tag = reader.uint32();
|
|
559
|
+
switch (tag >>> 3) {
|
|
560
|
+
case 1:
|
|
561
|
+
obj.msg = reader.string();
|
|
562
|
+
break;
|
|
563
|
+
default:
|
|
564
|
+
reader.skipType(tag & 7);
|
|
565
|
+
break;
|
|
566
|
+
}
|
|
567
|
+
}
|
|
568
|
+
if (obj.msg == null) {
|
|
569
|
+
throw new Error('Protocol error: value for required field "msg" was not found in protobuf');
|
|
570
|
+
}
|
|
571
|
+
return obj;
|
|
572
|
+
});
|
|
573
|
+
}
|
|
574
|
+
return _codec;
|
|
161
575
|
};
|
|
162
576
|
ErrorResponse.encode = (obj) => {
|
|
163
577
|
return encodeMessage(obj, ErrorResponse.codec());
|
|
@@ -168,12 +582,70 @@ export var ErrorResponse;
|
|
|
168
582
|
})(ErrorResponse || (ErrorResponse = {}));
|
|
169
583
|
export var StreamInfo;
|
|
170
584
|
(function (StreamInfo) {
|
|
585
|
+
let _codec;
|
|
171
586
|
StreamInfo.codec = () => {
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
587
|
+
if (_codec == null) {
|
|
588
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
589
|
+
if (opts.lengthDelimited !== false) {
|
|
590
|
+
writer.fork();
|
|
591
|
+
}
|
|
592
|
+
if (obj.peer != null) {
|
|
593
|
+
writer.uint32(10);
|
|
594
|
+
writer.bytes(obj.peer);
|
|
595
|
+
}
|
|
596
|
+
else {
|
|
597
|
+
throw new Error('Protocol error: required field "peer" was not found in object');
|
|
598
|
+
}
|
|
599
|
+
if (obj.addr != null) {
|
|
600
|
+
writer.uint32(18);
|
|
601
|
+
writer.bytes(obj.addr);
|
|
602
|
+
}
|
|
603
|
+
else {
|
|
604
|
+
throw new Error('Protocol error: required field "addr" was not found in object');
|
|
605
|
+
}
|
|
606
|
+
if (obj.proto != null) {
|
|
607
|
+
writer.uint32(26);
|
|
608
|
+
writer.string(obj.proto);
|
|
609
|
+
}
|
|
610
|
+
else {
|
|
611
|
+
throw new Error('Protocol error: required field "proto" was not found in object');
|
|
612
|
+
}
|
|
613
|
+
if (opts.lengthDelimited !== false) {
|
|
614
|
+
writer.ldelim();
|
|
615
|
+
}
|
|
616
|
+
}, (reader, length) => {
|
|
617
|
+
const obj = {};
|
|
618
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
619
|
+
while (reader.pos < end) {
|
|
620
|
+
const tag = reader.uint32();
|
|
621
|
+
switch (tag >>> 3) {
|
|
622
|
+
case 1:
|
|
623
|
+
obj.peer = reader.bytes();
|
|
624
|
+
break;
|
|
625
|
+
case 2:
|
|
626
|
+
obj.addr = reader.bytes();
|
|
627
|
+
break;
|
|
628
|
+
case 3:
|
|
629
|
+
obj.proto = reader.string();
|
|
630
|
+
break;
|
|
631
|
+
default:
|
|
632
|
+
reader.skipType(tag & 7);
|
|
633
|
+
break;
|
|
634
|
+
}
|
|
635
|
+
}
|
|
636
|
+
if (obj.peer == null) {
|
|
637
|
+
throw new Error('Protocol error: value for required field "peer" was not found in protobuf');
|
|
638
|
+
}
|
|
639
|
+
if (obj.addr == null) {
|
|
640
|
+
throw new Error('Protocol error: value for required field "addr" was not found in protobuf');
|
|
641
|
+
}
|
|
642
|
+
if (obj.proto == null) {
|
|
643
|
+
throw new Error('Protocol error: value for required field "proto" was not found in protobuf');
|
|
644
|
+
}
|
|
645
|
+
return obj;
|
|
646
|
+
});
|
|
647
|
+
}
|
|
648
|
+
return _codec;
|
|
177
649
|
};
|
|
178
650
|
StreamInfo.encode = (obj) => {
|
|
179
651
|
return encodeMessage(obj, StreamInfo.codec());
|
|
@@ -213,16 +685,86 @@ export var DHTRequest;
|
|
|
213
685
|
return enumeration(__TypeValues);
|
|
214
686
|
};
|
|
215
687
|
})(Type = DHTRequest.Type || (DHTRequest.Type = {}));
|
|
688
|
+
let _codec;
|
|
216
689
|
DHTRequest.codec = () => {
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
690
|
+
if (_codec == null) {
|
|
691
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
692
|
+
if (opts.lengthDelimited !== false) {
|
|
693
|
+
writer.fork();
|
|
694
|
+
}
|
|
695
|
+
if (obj.type != null) {
|
|
696
|
+
writer.uint32(8);
|
|
697
|
+
DHTRequest.Type.codec().encode(obj.type, writer);
|
|
698
|
+
}
|
|
699
|
+
else {
|
|
700
|
+
throw new Error('Protocol error: required field "type" was not found in object');
|
|
701
|
+
}
|
|
702
|
+
if (obj.peer != null) {
|
|
703
|
+
writer.uint32(18);
|
|
704
|
+
writer.bytes(obj.peer);
|
|
705
|
+
}
|
|
706
|
+
if (obj.cid != null) {
|
|
707
|
+
writer.uint32(26);
|
|
708
|
+
writer.bytes(obj.cid);
|
|
709
|
+
}
|
|
710
|
+
if (obj.key != null) {
|
|
711
|
+
writer.uint32(34);
|
|
712
|
+
writer.bytes(obj.key);
|
|
713
|
+
}
|
|
714
|
+
if (obj.value != null) {
|
|
715
|
+
writer.uint32(42);
|
|
716
|
+
writer.bytes(obj.value);
|
|
717
|
+
}
|
|
718
|
+
if (obj.count != null) {
|
|
719
|
+
writer.uint32(48);
|
|
720
|
+
writer.int32(obj.count);
|
|
721
|
+
}
|
|
722
|
+
if (obj.timeout != null) {
|
|
723
|
+
writer.uint32(56);
|
|
724
|
+
writer.int64(obj.timeout);
|
|
725
|
+
}
|
|
726
|
+
if (opts.lengthDelimited !== false) {
|
|
727
|
+
writer.ldelim();
|
|
728
|
+
}
|
|
729
|
+
}, (reader, length) => {
|
|
730
|
+
const obj = {};
|
|
731
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
732
|
+
while (reader.pos < end) {
|
|
733
|
+
const tag = reader.uint32();
|
|
734
|
+
switch (tag >>> 3) {
|
|
735
|
+
case 1:
|
|
736
|
+
obj.type = DHTRequest.Type.codec().decode(reader);
|
|
737
|
+
break;
|
|
738
|
+
case 2:
|
|
739
|
+
obj.peer = reader.bytes();
|
|
740
|
+
break;
|
|
741
|
+
case 3:
|
|
742
|
+
obj.cid = reader.bytes();
|
|
743
|
+
break;
|
|
744
|
+
case 4:
|
|
745
|
+
obj.key = reader.bytes();
|
|
746
|
+
break;
|
|
747
|
+
case 5:
|
|
748
|
+
obj.value = reader.bytes();
|
|
749
|
+
break;
|
|
750
|
+
case 6:
|
|
751
|
+
obj.count = reader.int32();
|
|
752
|
+
break;
|
|
753
|
+
case 7:
|
|
754
|
+
obj.timeout = reader.int64();
|
|
755
|
+
break;
|
|
756
|
+
default:
|
|
757
|
+
reader.skipType(tag & 7);
|
|
758
|
+
break;
|
|
759
|
+
}
|
|
760
|
+
}
|
|
761
|
+
if (obj.type == null) {
|
|
762
|
+
throw new Error('Protocol error: value for required field "type" was not found in protobuf');
|
|
763
|
+
}
|
|
764
|
+
return obj;
|
|
765
|
+
});
|
|
766
|
+
}
|
|
767
|
+
return _codec;
|
|
226
768
|
};
|
|
227
769
|
DHTRequest.encode = (obj) => {
|
|
228
770
|
return encodeMessage(obj, DHTRequest.codec());
|
|
@@ -250,12 +792,58 @@ export var DHTResponse;
|
|
|
250
792
|
return enumeration(__TypeValues);
|
|
251
793
|
};
|
|
252
794
|
})(Type = DHTResponse.Type || (DHTResponse.Type = {}));
|
|
795
|
+
let _codec;
|
|
253
796
|
DHTResponse.codec = () => {
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
797
|
+
if (_codec == null) {
|
|
798
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
799
|
+
if (opts.lengthDelimited !== false) {
|
|
800
|
+
writer.fork();
|
|
801
|
+
}
|
|
802
|
+
if (obj.type != null) {
|
|
803
|
+
writer.uint32(8);
|
|
804
|
+
DHTResponse.Type.codec().encode(obj.type, writer);
|
|
805
|
+
}
|
|
806
|
+
else {
|
|
807
|
+
throw new Error('Protocol error: required field "type" was not found in object');
|
|
808
|
+
}
|
|
809
|
+
if (obj.peer != null) {
|
|
810
|
+
writer.uint32(18);
|
|
811
|
+
PeerInfo.codec().encode(obj.peer, writer);
|
|
812
|
+
}
|
|
813
|
+
if (obj.value != null) {
|
|
814
|
+
writer.uint32(26);
|
|
815
|
+
writer.bytes(obj.value);
|
|
816
|
+
}
|
|
817
|
+
if (opts.lengthDelimited !== false) {
|
|
818
|
+
writer.ldelim();
|
|
819
|
+
}
|
|
820
|
+
}, (reader, length) => {
|
|
821
|
+
const obj = {};
|
|
822
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
823
|
+
while (reader.pos < end) {
|
|
824
|
+
const tag = reader.uint32();
|
|
825
|
+
switch (tag >>> 3) {
|
|
826
|
+
case 1:
|
|
827
|
+
obj.type = DHTResponse.Type.codec().decode(reader);
|
|
828
|
+
break;
|
|
829
|
+
case 2:
|
|
830
|
+
obj.peer = PeerInfo.codec().decode(reader, reader.uint32());
|
|
831
|
+
break;
|
|
832
|
+
case 3:
|
|
833
|
+
obj.value = reader.bytes();
|
|
834
|
+
break;
|
|
835
|
+
default:
|
|
836
|
+
reader.skipType(tag & 7);
|
|
837
|
+
break;
|
|
838
|
+
}
|
|
839
|
+
}
|
|
840
|
+
if (obj.type == null) {
|
|
841
|
+
throw new Error('Protocol error: value for required field "type" was not found in protobuf');
|
|
842
|
+
}
|
|
843
|
+
return obj;
|
|
844
|
+
});
|
|
845
|
+
}
|
|
846
|
+
return _codec;
|
|
259
847
|
};
|
|
260
848
|
DHTResponse.encode = (obj) => {
|
|
261
849
|
return encodeMessage(obj, DHTResponse.codec());
|
|
@@ -266,11 +854,61 @@ export var DHTResponse;
|
|
|
266
854
|
})(DHTResponse || (DHTResponse = {}));
|
|
267
855
|
export var PeerInfo;
|
|
268
856
|
(function (PeerInfo) {
|
|
857
|
+
let _codec;
|
|
269
858
|
PeerInfo.codec = () => {
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
859
|
+
if (_codec == null) {
|
|
860
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
861
|
+
if (opts.lengthDelimited !== false) {
|
|
862
|
+
writer.fork();
|
|
863
|
+
}
|
|
864
|
+
if (obj.id != null) {
|
|
865
|
+
writer.uint32(10);
|
|
866
|
+
writer.bytes(obj.id);
|
|
867
|
+
}
|
|
868
|
+
else {
|
|
869
|
+
throw new Error('Protocol error: required field "id" was not found in object');
|
|
870
|
+
}
|
|
871
|
+
if (obj.addrs != null) {
|
|
872
|
+
for (const value of obj.addrs) {
|
|
873
|
+
writer.uint32(18);
|
|
874
|
+
writer.bytes(value);
|
|
875
|
+
}
|
|
876
|
+
}
|
|
877
|
+
else {
|
|
878
|
+
throw new Error('Protocol error: required field "addrs" was not found in object');
|
|
879
|
+
}
|
|
880
|
+
if (opts.lengthDelimited !== false) {
|
|
881
|
+
writer.ldelim();
|
|
882
|
+
}
|
|
883
|
+
}, (reader, length) => {
|
|
884
|
+
const obj = {};
|
|
885
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
886
|
+
while (reader.pos < end) {
|
|
887
|
+
const tag = reader.uint32();
|
|
888
|
+
switch (tag >>> 3) {
|
|
889
|
+
case 1:
|
|
890
|
+
obj.id = reader.bytes();
|
|
891
|
+
break;
|
|
892
|
+
case 2:
|
|
893
|
+
obj.addrs = obj.addrs ?? [];
|
|
894
|
+
obj.addrs.push(reader.bytes());
|
|
895
|
+
break;
|
|
896
|
+
default:
|
|
897
|
+
reader.skipType(tag & 7);
|
|
898
|
+
break;
|
|
899
|
+
}
|
|
900
|
+
}
|
|
901
|
+
obj.addrs = obj.addrs ?? [];
|
|
902
|
+
if (obj.id == null) {
|
|
903
|
+
throw new Error('Protocol error: value for required field "id" was not found in protobuf');
|
|
904
|
+
}
|
|
905
|
+
if (obj.addrs == null) {
|
|
906
|
+
throw new Error('Protocol error: value for required field "addrs" was not found in protobuf');
|
|
907
|
+
}
|
|
908
|
+
return obj;
|
|
909
|
+
});
|
|
910
|
+
}
|
|
911
|
+
return _codec;
|
|
274
912
|
};
|
|
275
913
|
PeerInfo.encode = (obj) => {
|
|
276
914
|
return encodeMessage(obj, PeerInfo.codec());
|
|
@@ -298,13 +936,65 @@ export var ConnManagerRequest;
|
|
|
298
936
|
return enumeration(__TypeValues);
|
|
299
937
|
};
|
|
300
938
|
})(Type = ConnManagerRequest.Type || (ConnManagerRequest.Type = {}));
|
|
939
|
+
let _codec;
|
|
301
940
|
ConnManagerRequest.codec = () => {
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
941
|
+
if (_codec == null) {
|
|
942
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
943
|
+
if (opts.lengthDelimited !== false) {
|
|
944
|
+
writer.fork();
|
|
945
|
+
}
|
|
946
|
+
if (obj.type != null) {
|
|
947
|
+
writer.uint32(8);
|
|
948
|
+
ConnManagerRequest.Type.codec().encode(obj.type, writer);
|
|
949
|
+
}
|
|
950
|
+
else {
|
|
951
|
+
throw new Error('Protocol error: required field "type" was not found in object');
|
|
952
|
+
}
|
|
953
|
+
if (obj.peer != null) {
|
|
954
|
+
writer.uint32(18);
|
|
955
|
+
writer.bytes(obj.peer);
|
|
956
|
+
}
|
|
957
|
+
if (obj.tag != null) {
|
|
958
|
+
writer.uint32(26);
|
|
959
|
+
writer.string(obj.tag);
|
|
960
|
+
}
|
|
961
|
+
if (obj.weight != null) {
|
|
962
|
+
writer.uint32(32);
|
|
963
|
+
writer.int64(obj.weight);
|
|
964
|
+
}
|
|
965
|
+
if (opts.lengthDelimited !== false) {
|
|
966
|
+
writer.ldelim();
|
|
967
|
+
}
|
|
968
|
+
}, (reader, length) => {
|
|
969
|
+
const obj = {};
|
|
970
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
971
|
+
while (reader.pos < end) {
|
|
972
|
+
const tag = reader.uint32();
|
|
973
|
+
switch (tag >>> 3) {
|
|
974
|
+
case 1:
|
|
975
|
+
obj.type = ConnManagerRequest.Type.codec().decode(reader);
|
|
976
|
+
break;
|
|
977
|
+
case 2:
|
|
978
|
+
obj.peer = reader.bytes();
|
|
979
|
+
break;
|
|
980
|
+
case 3:
|
|
981
|
+
obj.tag = reader.string();
|
|
982
|
+
break;
|
|
983
|
+
case 4:
|
|
984
|
+
obj.weight = reader.int64();
|
|
985
|
+
break;
|
|
986
|
+
default:
|
|
987
|
+
reader.skipType(tag & 7);
|
|
988
|
+
break;
|
|
989
|
+
}
|
|
990
|
+
}
|
|
991
|
+
if (obj.type == null) {
|
|
992
|
+
throw new Error('Protocol error: value for required field "type" was not found in protobuf');
|
|
993
|
+
}
|
|
994
|
+
return obj;
|
|
995
|
+
});
|
|
996
|
+
}
|
|
997
|
+
return _codec;
|
|
308
998
|
};
|
|
309
999
|
ConnManagerRequest.encode = (obj) => {
|
|
310
1000
|
return encodeMessage(obj, ConnManagerRequest.codec());
|
|
@@ -315,10 +1005,44 @@ export var ConnManagerRequest;
|
|
|
315
1005
|
})(ConnManagerRequest || (ConnManagerRequest = {}));
|
|
316
1006
|
export var DisconnectRequest;
|
|
317
1007
|
(function (DisconnectRequest) {
|
|
1008
|
+
let _codec;
|
|
318
1009
|
DisconnectRequest.codec = () => {
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
1010
|
+
if (_codec == null) {
|
|
1011
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
1012
|
+
if (opts.lengthDelimited !== false) {
|
|
1013
|
+
writer.fork();
|
|
1014
|
+
}
|
|
1015
|
+
if (obj.peer != null) {
|
|
1016
|
+
writer.uint32(10);
|
|
1017
|
+
writer.bytes(obj.peer);
|
|
1018
|
+
}
|
|
1019
|
+
else {
|
|
1020
|
+
throw new Error('Protocol error: required field "peer" was not found in object');
|
|
1021
|
+
}
|
|
1022
|
+
if (opts.lengthDelimited !== false) {
|
|
1023
|
+
writer.ldelim();
|
|
1024
|
+
}
|
|
1025
|
+
}, (reader, length) => {
|
|
1026
|
+
const obj = {};
|
|
1027
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1028
|
+
while (reader.pos < end) {
|
|
1029
|
+
const tag = reader.uint32();
|
|
1030
|
+
switch (tag >>> 3) {
|
|
1031
|
+
case 1:
|
|
1032
|
+
obj.peer = reader.bytes();
|
|
1033
|
+
break;
|
|
1034
|
+
default:
|
|
1035
|
+
reader.skipType(tag & 7);
|
|
1036
|
+
break;
|
|
1037
|
+
}
|
|
1038
|
+
}
|
|
1039
|
+
if (obj.peer == null) {
|
|
1040
|
+
throw new Error('Protocol error: value for required field "peer" was not found in protobuf');
|
|
1041
|
+
}
|
|
1042
|
+
return obj;
|
|
1043
|
+
});
|
|
1044
|
+
}
|
|
1045
|
+
return _codec;
|
|
322
1046
|
};
|
|
323
1047
|
DisconnectRequest.encode = (obj) => {
|
|
324
1048
|
return encodeMessage(obj, DisconnectRequest.codec());
|
|
@@ -348,12 +1072,58 @@ export var PSRequest;
|
|
|
348
1072
|
return enumeration(__TypeValues);
|
|
349
1073
|
};
|
|
350
1074
|
})(Type = PSRequest.Type || (PSRequest.Type = {}));
|
|
1075
|
+
let _codec;
|
|
351
1076
|
PSRequest.codec = () => {
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
1077
|
+
if (_codec == null) {
|
|
1078
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
1079
|
+
if (opts.lengthDelimited !== false) {
|
|
1080
|
+
writer.fork();
|
|
1081
|
+
}
|
|
1082
|
+
if (obj.type != null) {
|
|
1083
|
+
writer.uint32(8);
|
|
1084
|
+
PSRequest.Type.codec().encode(obj.type, writer);
|
|
1085
|
+
}
|
|
1086
|
+
else {
|
|
1087
|
+
throw new Error('Protocol error: required field "type" was not found in object');
|
|
1088
|
+
}
|
|
1089
|
+
if (obj.topic != null) {
|
|
1090
|
+
writer.uint32(18);
|
|
1091
|
+
writer.string(obj.topic);
|
|
1092
|
+
}
|
|
1093
|
+
if (obj.data != null) {
|
|
1094
|
+
writer.uint32(26);
|
|
1095
|
+
writer.bytes(obj.data);
|
|
1096
|
+
}
|
|
1097
|
+
if (opts.lengthDelimited !== false) {
|
|
1098
|
+
writer.ldelim();
|
|
1099
|
+
}
|
|
1100
|
+
}, (reader, length) => {
|
|
1101
|
+
const obj = {};
|
|
1102
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1103
|
+
while (reader.pos < end) {
|
|
1104
|
+
const tag = reader.uint32();
|
|
1105
|
+
switch (tag >>> 3) {
|
|
1106
|
+
case 1:
|
|
1107
|
+
obj.type = PSRequest.Type.codec().decode(reader);
|
|
1108
|
+
break;
|
|
1109
|
+
case 2:
|
|
1110
|
+
obj.topic = reader.string();
|
|
1111
|
+
break;
|
|
1112
|
+
case 3:
|
|
1113
|
+
obj.data = reader.bytes();
|
|
1114
|
+
break;
|
|
1115
|
+
default:
|
|
1116
|
+
reader.skipType(tag & 7);
|
|
1117
|
+
break;
|
|
1118
|
+
}
|
|
1119
|
+
}
|
|
1120
|
+
if (obj.type == null) {
|
|
1121
|
+
throw new Error('Protocol error: value for required field "type" was not found in protobuf');
|
|
1122
|
+
}
|
|
1123
|
+
return obj;
|
|
1124
|
+
});
|
|
1125
|
+
}
|
|
1126
|
+
return _codec;
|
|
357
1127
|
};
|
|
358
1128
|
PSRequest.encode = (obj) => {
|
|
359
1129
|
return encodeMessage(obj, PSRequest.codec());
|
|
@@ -364,15 +1134,83 @@ export var PSRequest;
|
|
|
364
1134
|
})(PSRequest || (PSRequest = {}));
|
|
365
1135
|
export var PSMessage;
|
|
366
1136
|
(function (PSMessage) {
|
|
1137
|
+
let _codec;
|
|
367
1138
|
PSMessage.codec = () => {
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
1139
|
+
if (_codec == null) {
|
|
1140
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
1141
|
+
if (opts.lengthDelimited !== false) {
|
|
1142
|
+
writer.fork();
|
|
1143
|
+
}
|
|
1144
|
+
if (obj.from != null) {
|
|
1145
|
+
writer.uint32(10);
|
|
1146
|
+
writer.bytes(obj.from);
|
|
1147
|
+
}
|
|
1148
|
+
if (obj.data != null) {
|
|
1149
|
+
writer.uint32(18);
|
|
1150
|
+
writer.bytes(obj.data);
|
|
1151
|
+
}
|
|
1152
|
+
if (obj.seqno != null) {
|
|
1153
|
+
writer.uint32(26);
|
|
1154
|
+
writer.bytes(obj.seqno);
|
|
1155
|
+
}
|
|
1156
|
+
if (obj.topicIDs != null) {
|
|
1157
|
+
for (const value of obj.topicIDs) {
|
|
1158
|
+
writer.uint32(34);
|
|
1159
|
+
writer.string(value);
|
|
1160
|
+
}
|
|
1161
|
+
}
|
|
1162
|
+
else {
|
|
1163
|
+
throw new Error('Protocol error: required field "topicIDs" was not found in object');
|
|
1164
|
+
}
|
|
1165
|
+
if (obj.signature != null) {
|
|
1166
|
+
writer.uint32(42);
|
|
1167
|
+
writer.bytes(obj.signature);
|
|
1168
|
+
}
|
|
1169
|
+
if (obj.key != null) {
|
|
1170
|
+
writer.uint32(50);
|
|
1171
|
+
writer.bytes(obj.key);
|
|
1172
|
+
}
|
|
1173
|
+
if (opts.lengthDelimited !== false) {
|
|
1174
|
+
writer.ldelim();
|
|
1175
|
+
}
|
|
1176
|
+
}, (reader, length) => {
|
|
1177
|
+
const obj = {};
|
|
1178
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1179
|
+
while (reader.pos < end) {
|
|
1180
|
+
const tag = reader.uint32();
|
|
1181
|
+
switch (tag >>> 3) {
|
|
1182
|
+
case 1:
|
|
1183
|
+
obj.from = reader.bytes();
|
|
1184
|
+
break;
|
|
1185
|
+
case 2:
|
|
1186
|
+
obj.data = reader.bytes();
|
|
1187
|
+
break;
|
|
1188
|
+
case 3:
|
|
1189
|
+
obj.seqno = reader.bytes();
|
|
1190
|
+
break;
|
|
1191
|
+
case 4:
|
|
1192
|
+
obj.topicIDs = obj.topicIDs ?? [];
|
|
1193
|
+
obj.topicIDs.push(reader.string());
|
|
1194
|
+
break;
|
|
1195
|
+
case 5:
|
|
1196
|
+
obj.signature = reader.bytes();
|
|
1197
|
+
break;
|
|
1198
|
+
case 6:
|
|
1199
|
+
obj.key = reader.bytes();
|
|
1200
|
+
break;
|
|
1201
|
+
default:
|
|
1202
|
+
reader.skipType(tag & 7);
|
|
1203
|
+
break;
|
|
1204
|
+
}
|
|
1205
|
+
}
|
|
1206
|
+
obj.topicIDs = obj.topicIDs ?? [];
|
|
1207
|
+
if (obj.topicIDs == null) {
|
|
1208
|
+
throw new Error('Protocol error: value for required field "topicIDs" was not found in protobuf');
|
|
1209
|
+
}
|
|
1210
|
+
return obj;
|
|
1211
|
+
});
|
|
1212
|
+
}
|
|
1213
|
+
return _codec;
|
|
376
1214
|
};
|
|
377
1215
|
PSMessage.encode = (obj) => {
|
|
378
1216
|
return encodeMessage(obj, PSMessage.codec());
|
|
@@ -383,11 +1221,65 @@ export var PSMessage;
|
|
|
383
1221
|
})(PSMessage || (PSMessage = {}));
|
|
384
1222
|
export var PSResponse;
|
|
385
1223
|
(function (PSResponse) {
|
|
1224
|
+
let _codec;
|
|
386
1225
|
PSResponse.codec = () => {
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
1226
|
+
if (_codec == null) {
|
|
1227
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
1228
|
+
if (opts.lengthDelimited !== false) {
|
|
1229
|
+
writer.fork();
|
|
1230
|
+
}
|
|
1231
|
+
if (obj.topics != null) {
|
|
1232
|
+
for (const value of obj.topics) {
|
|
1233
|
+
writer.uint32(10);
|
|
1234
|
+
writer.string(value);
|
|
1235
|
+
}
|
|
1236
|
+
}
|
|
1237
|
+
else {
|
|
1238
|
+
throw new Error('Protocol error: required field "topics" was not found in object');
|
|
1239
|
+
}
|
|
1240
|
+
if (obj.peerIDs != null) {
|
|
1241
|
+
for (const value of obj.peerIDs) {
|
|
1242
|
+
writer.uint32(18);
|
|
1243
|
+
writer.bytes(value);
|
|
1244
|
+
}
|
|
1245
|
+
}
|
|
1246
|
+
else {
|
|
1247
|
+
throw new Error('Protocol error: required field "peerIDs" was not found in object');
|
|
1248
|
+
}
|
|
1249
|
+
if (opts.lengthDelimited !== false) {
|
|
1250
|
+
writer.ldelim();
|
|
1251
|
+
}
|
|
1252
|
+
}, (reader, length) => {
|
|
1253
|
+
const obj = {};
|
|
1254
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1255
|
+
while (reader.pos < end) {
|
|
1256
|
+
const tag = reader.uint32();
|
|
1257
|
+
switch (tag >>> 3) {
|
|
1258
|
+
case 1:
|
|
1259
|
+
obj.topics = obj.topics ?? [];
|
|
1260
|
+
obj.topics.push(reader.string());
|
|
1261
|
+
break;
|
|
1262
|
+
case 2:
|
|
1263
|
+
obj.peerIDs = obj.peerIDs ?? [];
|
|
1264
|
+
obj.peerIDs.push(reader.bytes());
|
|
1265
|
+
break;
|
|
1266
|
+
default:
|
|
1267
|
+
reader.skipType(tag & 7);
|
|
1268
|
+
break;
|
|
1269
|
+
}
|
|
1270
|
+
}
|
|
1271
|
+
obj.topics = obj.topics ?? [];
|
|
1272
|
+
obj.peerIDs = obj.peerIDs ?? [];
|
|
1273
|
+
if (obj.topics == null) {
|
|
1274
|
+
throw new Error('Protocol error: value for required field "topics" was not found in protobuf');
|
|
1275
|
+
}
|
|
1276
|
+
if (obj.peerIDs == null) {
|
|
1277
|
+
throw new Error('Protocol error: value for required field "peerIDs" was not found in protobuf');
|
|
1278
|
+
}
|
|
1279
|
+
return obj;
|
|
1280
|
+
});
|
|
1281
|
+
}
|
|
1282
|
+
return _codec;
|
|
391
1283
|
};
|
|
392
1284
|
PSResponse.encode = (obj) => {
|
|
393
1285
|
return encodeMessage(obj, PSResponse.codec());
|
|
@@ -413,12 +1305,68 @@ export var PeerstoreRequest;
|
|
|
413
1305
|
return enumeration(__TypeValues);
|
|
414
1306
|
};
|
|
415
1307
|
})(Type = PeerstoreRequest.Type || (PeerstoreRequest.Type = {}));
|
|
1308
|
+
let _codec;
|
|
416
1309
|
PeerstoreRequest.codec = () => {
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
1310
|
+
if (_codec == null) {
|
|
1311
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
1312
|
+
if (opts.lengthDelimited !== false) {
|
|
1313
|
+
writer.fork();
|
|
1314
|
+
}
|
|
1315
|
+
if (obj.type != null) {
|
|
1316
|
+
writer.uint32(8);
|
|
1317
|
+
PeerstoreRequest.Type.codec().encode(obj.type, writer);
|
|
1318
|
+
}
|
|
1319
|
+
else {
|
|
1320
|
+
throw new Error('Protocol error: required field "type" was not found in object');
|
|
1321
|
+
}
|
|
1322
|
+
if (obj.id != null) {
|
|
1323
|
+
writer.uint32(18);
|
|
1324
|
+
writer.bytes(obj.id);
|
|
1325
|
+
}
|
|
1326
|
+
if (obj.protos != null) {
|
|
1327
|
+
for (const value of obj.protos) {
|
|
1328
|
+
writer.uint32(26);
|
|
1329
|
+
writer.string(value);
|
|
1330
|
+
}
|
|
1331
|
+
}
|
|
1332
|
+
else {
|
|
1333
|
+
throw new Error('Protocol error: required field "protos" was not found in object');
|
|
1334
|
+
}
|
|
1335
|
+
if (opts.lengthDelimited !== false) {
|
|
1336
|
+
writer.ldelim();
|
|
1337
|
+
}
|
|
1338
|
+
}, (reader, length) => {
|
|
1339
|
+
const obj = {};
|
|
1340
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1341
|
+
while (reader.pos < end) {
|
|
1342
|
+
const tag = reader.uint32();
|
|
1343
|
+
switch (tag >>> 3) {
|
|
1344
|
+
case 1:
|
|
1345
|
+
obj.type = PeerstoreRequest.Type.codec().decode(reader);
|
|
1346
|
+
break;
|
|
1347
|
+
case 2:
|
|
1348
|
+
obj.id = reader.bytes();
|
|
1349
|
+
break;
|
|
1350
|
+
case 3:
|
|
1351
|
+
obj.protos = obj.protos ?? [];
|
|
1352
|
+
obj.protos.push(reader.string());
|
|
1353
|
+
break;
|
|
1354
|
+
default:
|
|
1355
|
+
reader.skipType(tag & 7);
|
|
1356
|
+
break;
|
|
1357
|
+
}
|
|
1358
|
+
}
|
|
1359
|
+
obj.protos = obj.protos ?? [];
|
|
1360
|
+
if (obj.type == null) {
|
|
1361
|
+
throw new Error('Protocol error: value for required field "type" was not found in protobuf');
|
|
1362
|
+
}
|
|
1363
|
+
if (obj.protos == null) {
|
|
1364
|
+
throw new Error('Protocol error: value for required field "protos" was not found in protobuf');
|
|
1365
|
+
}
|
|
1366
|
+
return obj;
|
|
1367
|
+
});
|
|
1368
|
+
}
|
|
1369
|
+
return _codec;
|
|
422
1370
|
};
|
|
423
1371
|
PeerstoreRequest.encode = (obj) => {
|
|
424
1372
|
return encodeMessage(obj, PeerstoreRequest.codec());
|
|
@@ -429,11 +1377,55 @@ export var PeerstoreRequest;
|
|
|
429
1377
|
})(PeerstoreRequest || (PeerstoreRequest = {}));
|
|
430
1378
|
export var PeerstoreResponse;
|
|
431
1379
|
(function (PeerstoreResponse) {
|
|
1380
|
+
let _codec;
|
|
432
1381
|
PeerstoreResponse.codec = () => {
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
1382
|
+
if (_codec == null) {
|
|
1383
|
+
_codec = message((obj, writer, opts = {}) => {
|
|
1384
|
+
if (opts.lengthDelimited !== false) {
|
|
1385
|
+
writer.fork();
|
|
1386
|
+
}
|
|
1387
|
+
if (obj.peer != null) {
|
|
1388
|
+
writer.uint32(10);
|
|
1389
|
+
PeerInfo.codec().encode(obj.peer, writer);
|
|
1390
|
+
}
|
|
1391
|
+
if (obj.protos != null) {
|
|
1392
|
+
for (const value of obj.protos) {
|
|
1393
|
+
writer.uint32(18);
|
|
1394
|
+
writer.string(value);
|
|
1395
|
+
}
|
|
1396
|
+
}
|
|
1397
|
+
else {
|
|
1398
|
+
throw new Error('Protocol error: required field "protos" was not found in object');
|
|
1399
|
+
}
|
|
1400
|
+
if (opts.lengthDelimited !== false) {
|
|
1401
|
+
writer.ldelim();
|
|
1402
|
+
}
|
|
1403
|
+
}, (reader, length) => {
|
|
1404
|
+
const obj = {};
|
|
1405
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
1406
|
+
while (reader.pos < end) {
|
|
1407
|
+
const tag = reader.uint32();
|
|
1408
|
+
switch (tag >>> 3) {
|
|
1409
|
+
case 1:
|
|
1410
|
+
obj.peer = PeerInfo.codec().decode(reader, reader.uint32());
|
|
1411
|
+
break;
|
|
1412
|
+
case 2:
|
|
1413
|
+
obj.protos = obj.protos ?? [];
|
|
1414
|
+
obj.protos.push(reader.string());
|
|
1415
|
+
break;
|
|
1416
|
+
default:
|
|
1417
|
+
reader.skipType(tag & 7);
|
|
1418
|
+
break;
|
|
1419
|
+
}
|
|
1420
|
+
}
|
|
1421
|
+
obj.protos = obj.protos ?? [];
|
|
1422
|
+
if (obj.protos == null) {
|
|
1423
|
+
throw new Error('Protocol error: value for required field "protos" was not found in protobuf');
|
|
1424
|
+
}
|
|
1425
|
+
return obj;
|
|
1426
|
+
});
|
|
1427
|
+
}
|
|
1428
|
+
return _codec;
|
|
437
1429
|
};
|
|
438
1430
|
PeerstoreResponse.encode = (obj) => {
|
|
439
1431
|
return encodeMessage(obj, PeerstoreResponse.codec());
|