@libp2p/interop 14.0.15 → 14.0.16
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 +2 -2
- package/dist/src/relay/pb/index.d.ts +124 -13
- package/dist/src/relay/pb/index.d.ts.map +1 -1
- package/dist/src/relay/pb/index.js +360 -72
- package/dist/src/relay/pb/index.js.map +1 -1
- package/package.json +6 -6
- package/src/relay/pb/index.ts +495 -61
|
@@ -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 HopMessage;
|
|
3
4
|
(function (HopMessage) {
|
|
4
5
|
let Type;
|
|
@@ -48,43 +49,104 @@ export var HopMessage;
|
|
|
48
49
|
if (opts.lengthDelimited !== false) {
|
|
49
50
|
w.ldelim();
|
|
50
51
|
}
|
|
51
|
-
}, (reader, length) => {
|
|
52
|
+
}, (reader, length, opts = {}) => {
|
|
52
53
|
const obj = {};
|
|
53
54
|
const end = length == null ? reader.len : reader.pos + length;
|
|
54
55
|
while (reader.pos < end) {
|
|
55
56
|
const tag = reader.uint32();
|
|
56
57
|
switch (tag >>> 3) {
|
|
57
|
-
case 1:
|
|
58
|
+
case 1: {
|
|
58
59
|
obj.type = HopMessage.Type.codec().decode(reader);
|
|
59
60
|
break;
|
|
60
|
-
|
|
61
|
-
|
|
61
|
+
}
|
|
62
|
+
case 2: {
|
|
63
|
+
obj.peer = Peer.codec().decode(reader, reader.uint32(), {
|
|
64
|
+
limits: opts.limits?.peer
|
|
65
|
+
});
|
|
62
66
|
break;
|
|
63
|
-
|
|
64
|
-
|
|
67
|
+
}
|
|
68
|
+
case 3: {
|
|
69
|
+
obj.reservation = Reservation.codec().decode(reader, reader.uint32(), {
|
|
70
|
+
limits: opts.limits?.reservation
|
|
71
|
+
});
|
|
65
72
|
break;
|
|
66
|
-
|
|
67
|
-
|
|
73
|
+
}
|
|
74
|
+
case 4: {
|
|
75
|
+
obj.limit = Limit.codec().decode(reader, reader.uint32(), {
|
|
76
|
+
limits: opts.limits?.limit
|
|
77
|
+
});
|
|
68
78
|
break;
|
|
69
|
-
|
|
79
|
+
}
|
|
80
|
+
case 5: {
|
|
70
81
|
obj.status = Status.codec().decode(reader);
|
|
71
82
|
break;
|
|
72
|
-
|
|
83
|
+
}
|
|
84
|
+
default: {
|
|
73
85
|
reader.skipType(tag & 7);
|
|
74
86
|
break;
|
|
87
|
+
}
|
|
75
88
|
}
|
|
76
89
|
}
|
|
77
90
|
return obj;
|
|
91
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
92
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
93
|
+
while (reader.pos < end) {
|
|
94
|
+
const tag = reader.uint32();
|
|
95
|
+
switch (tag >>> 3) {
|
|
96
|
+
case 1: {
|
|
97
|
+
yield {
|
|
98
|
+
field: `${prefix}.type`,
|
|
99
|
+
value: HopMessage.Type.codec().decode(reader)
|
|
100
|
+
};
|
|
101
|
+
break;
|
|
102
|
+
}
|
|
103
|
+
case 2: {
|
|
104
|
+
yield* Peer.codec().stream(reader, reader.uint32(), `${prefix}.peer`, {
|
|
105
|
+
limits: opts.limits?.peer
|
|
106
|
+
});
|
|
107
|
+
break;
|
|
108
|
+
}
|
|
109
|
+
case 3: {
|
|
110
|
+
yield* Reservation.codec().stream(reader, reader.uint32(), `${prefix}.reservation`, {
|
|
111
|
+
limits: opts.limits?.reservation
|
|
112
|
+
});
|
|
113
|
+
break;
|
|
114
|
+
}
|
|
115
|
+
case 4: {
|
|
116
|
+
yield* Limit.codec().stream(reader, reader.uint32(), `${prefix}.limit`, {
|
|
117
|
+
limits: opts.limits?.limit
|
|
118
|
+
});
|
|
119
|
+
break;
|
|
120
|
+
}
|
|
121
|
+
case 5: {
|
|
122
|
+
yield {
|
|
123
|
+
field: `${prefix}.status`,
|
|
124
|
+
value: Status.codec().decode(reader)
|
|
125
|
+
};
|
|
126
|
+
break;
|
|
127
|
+
}
|
|
128
|
+
default: {
|
|
129
|
+
reader.skipType(tag & 7);
|
|
130
|
+
break;
|
|
131
|
+
}
|
|
132
|
+
}
|
|
133
|
+
}
|
|
78
134
|
});
|
|
79
135
|
}
|
|
80
136
|
return _codec;
|
|
81
137
|
};
|
|
82
|
-
|
|
138
|
+
function encode(obj) {
|
|
83
139
|
return encodeMessage(obj, HopMessage.codec());
|
|
84
|
-
}
|
|
85
|
-
HopMessage.
|
|
86
|
-
|
|
87
|
-
|
|
140
|
+
}
|
|
141
|
+
HopMessage.encode = encode;
|
|
142
|
+
function decode(buf, opts) {
|
|
143
|
+
return decodeMessage(buf, HopMessage.codec(), opts);
|
|
144
|
+
}
|
|
145
|
+
HopMessage.decode = decode;
|
|
146
|
+
function stream(buf, opts) {
|
|
147
|
+
return streamMessage(buf, HopMessage.codec(), opts);
|
|
148
|
+
}
|
|
149
|
+
HopMessage.stream = stream;
|
|
88
150
|
})(HopMessage || (HopMessage = {}));
|
|
89
151
|
export var StopMessage;
|
|
90
152
|
(function (StopMessage) {
|
|
@@ -129,40 +191,92 @@ export var StopMessage;
|
|
|
129
191
|
if (opts.lengthDelimited !== false) {
|
|
130
192
|
w.ldelim();
|
|
131
193
|
}
|
|
132
|
-
}, (reader, length) => {
|
|
194
|
+
}, (reader, length, opts = {}) => {
|
|
133
195
|
const obj = {};
|
|
134
196
|
const end = length == null ? reader.len : reader.pos + length;
|
|
135
197
|
while (reader.pos < end) {
|
|
136
198
|
const tag = reader.uint32();
|
|
137
199
|
switch (tag >>> 3) {
|
|
138
|
-
case 1:
|
|
200
|
+
case 1: {
|
|
139
201
|
obj.type = StopMessage.Type.codec().decode(reader);
|
|
140
202
|
break;
|
|
141
|
-
|
|
142
|
-
|
|
203
|
+
}
|
|
204
|
+
case 2: {
|
|
205
|
+
obj.peer = Peer.codec().decode(reader, reader.uint32(), {
|
|
206
|
+
limits: opts.limits?.peer
|
|
207
|
+
});
|
|
143
208
|
break;
|
|
144
|
-
|
|
145
|
-
|
|
209
|
+
}
|
|
210
|
+
case 3: {
|
|
211
|
+
obj.limit = Limit.codec().decode(reader, reader.uint32(), {
|
|
212
|
+
limits: opts.limits?.limit
|
|
213
|
+
});
|
|
146
214
|
break;
|
|
147
|
-
|
|
215
|
+
}
|
|
216
|
+
case 4: {
|
|
148
217
|
obj.status = Status.codec().decode(reader);
|
|
149
218
|
break;
|
|
150
|
-
|
|
219
|
+
}
|
|
220
|
+
default: {
|
|
151
221
|
reader.skipType(tag & 7);
|
|
152
222
|
break;
|
|
223
|
+
}
|
|
153
224
|
}
|
|
154
225
|
}
|
|
155
226
|
return obj;
|
|
227
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
228
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
229
|
+
while (reader.pos < end) {
|
|
230
|
+
const tag = reader.uint32();
|
|
231
|
+
switch (tag >>> 3) {
|
|
232
|
+
case 1: {
|
|
233
|
+
yield {
|
|
234
|
+
field: `${prefix}.type`,
|
|
235
|
+
value: StopMessage.Type.codec().decode(reader)
|
|
236
|
+
};
|
|
237
|
+
break;
|
|
238
|
+
}
|
|
239
|
+
case 2: {
|
|
240
|
+
yield* Peer.codec().stream(reader, reader.uint32(), `${prefix}.peer`, {
|
|
241
|
+
limits: opts.limits?.peer
|
|
242
|
+
});
|
|
243
|
+
break;
|
|
244
|
+
}
|
|
245
|
+
case 3: {
|
|
246
|
+
yield* Limit.codec().stream(reader, reader.uint32(), `${prefix}.limit`, {
|
|
247
|
+
limits: opts.limits?.limit
|
|
248
|
+
});
|
|
249
|
+
break;
|
|
250
|
+
}
|
|
251
|
+
case 4: {
|
|
252
|
+
yield {
|
|
253
|
+
field: `${prefix}.status`,
|
|
254
|
+
value: Status.codec().decode(reader)
|
|
255
|
+
};
|
|
256
|
+
break;
|
|
257
|
+
}
|
|
258
|
+
default: {
|
|
259
|
+
reader.skipType(tag & 7);
|
|
260
|
+
break;
|
|
261
|
+
}
|
|
262
|
+
}
|
|
263
|
+
}
|
|
156
264
|
});
|
|
157
265
|
}
|
|
158
266
|
return _codec;
|
|
159
267
|
};
|
|
160
|
-
|
|
268
|
+
function encode(obj) {
|
|
161
269
|
return encodeMessage(obj, StopMessage.codec());
|
|
162
|
-
}
|
|
163
|
-
StopMessage.
|
|
164
|
-
|
|
165
|
-
|
|
270
|
+
}
|
|
271
|
+
StopMessage.encode = encode;
|
|
272
|
+
function decode(buf, opts) {
|
|
273
|
+
return decodeMessage(buf, StopMessage.codec(), opts);
|
|
274
|
+
}
|
|
275
|
+
StopMessage.decode = decode;
|
|
276
|
+
function stream(buf, opts) {
|
|
277
|
+
return streamMessage(buf, StopMessage.codec(), opts);
|
|
278
|
+
}
|
|
279
|
+
StopMessage.stream = stream;
|
|
166
280
|
})(StopMessage || (StopMessage = {}));
|
|
167
281
|
export var Peer;
|
|
168
282
|
(function (Peer) {
|
|
@@ -177,7 +291,7 @@ export var Peer;
|
|
|
177
291
|
w.uint32(10);
|
|
178
292
|
w.bytes(obj.id);
|
|
179
293
|
}
|
|
180
|
-
if (obj.addrs != null) {
|
|
294
|
+
if (obj.addrs != null && obj.addrs.length > 0) {
|
|
181
295
|
for (const value of obj.addrs) {
|
|
182
296
|
w.uint32(18);
|
|
183
297
|
w.bytes(value);
|
|
@@ -186,37 +300,82 @@ export var Peer;
|
|
|
186
300
|
if (opts.lengthDelimited !== false) {
|
|
187
301
|
w.ldelim();
|
|
188
302
|
}
|
|
189
|
-
}, (reader, length) => {
|
|
303
|
+
}, (reader, length, opts = {}) => {
|
|
190
304
|
const obj = {
|
|
191
|
-
id:
|
|
305
|
+
id: uint8ArrayAlloc(0),
|
|
192
306
|
addrs: []
|
|
193
307
|
};
|
|
194
308
|
const end = length == null ? reader.len : reader.pos + length;
|
|
195
309
|
while (reader.pos < end) {
|
|
196
310
|
const tag = reader.uint32();
|
|
197
311
|
switch (tag >>> 3) {
|
|
198
|
-
case 1:
|
|
312
|
+
case 1: {
|
|
199
313
|
obj.id = reader.bytes();
|
|
200
314
|
break;
|
|
201
|
-
|
|
315
|
+
}
|
|
316
|
+
case 2: {
|
|
317
|
+
if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
|
|
318
|
+
throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements');
|
|
319
|
+
}
|
|
202
320
|
obj.addrs.push(reader.bytes());
|
|
203
321
|
break;
|
|
204
|
-
|
|
322
|
+
}
|
|
323
|
+
default: {
|
|
205
324
|
reader.skipType(tag & 7);
|
|
206
325
|
break;
|
|
326
|
+
}
|
|
207
327
|
}
|
|
208
328
|
}
|
|
209
329
|
return obj;
|
|
330
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
331
|
+
const obj = {
|
|
332
|
+
addrs: 0
|
|
333
|
+
};
|
|
334
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
335
|
+
while (reader.pos < end) {
|
|
336
|
+
const tag = reader.uint32();
|
|
337
|
+
switch (tag >>> 3) {
|
|
338
|
+
case 1: {
|
|
339
|
+
yield {
|
|
340
|
+
field: `${prefix}.id`,
|
|
341
|
+
value: reader.bytes()
|
|
342
|
+
};
|
|
343
|
+
break;
|
|
344
|
+
}
|
|
345
|
+
case 2: {
|
|
346
|
+
if (opts.limits?.addrs != null && obj.addrs === opts.limits.addrs) {
|
|
347
|
+
throw new MaxLengthError('Streaming decode error - repeated field "addrs" had too many elements');
|
|
348
|
+
}
|
|
349
|
+
yield {
|
|
350
|
+
field: `${prefix}.addrs[]`,
|
|
351
|
+
index: obj.addrs,
|
|
352
|
+
value: reader.bytes()
|
|
353
|
+
};
|
|
354
|
+
obj.addrs++;
|
|
355
|
+
break;
|
|
356
|
+
}
|
|
357
|
+
default: {
|
|
358
|
+
reader.skipType(tag & 7);
|
|
359
|
+
break;
|
|
360
|
+
}
|
|
361
|
+
}
|
|
362
|
+
}
|
|
210
363
|
});
|
|
211
364
|
}
|
|
212
365
|
return _codec;
|
|
213
366
|
};
|
|
214
|
-
|
|
367
|
+
function encode(obj) {
|
|
215
368
|
return encodeMessage(obj, Peer.codec());
|
|
216
|
-
}
|
|
217
|
-
Peer.
|
|
218
|
-
|
|
219
|
-
|
|
369
|
+
}
|
|
370
|
+
Peer.encode = encode;
|
|
371
|
+
function decode(buf, opts) {
|
|
372
|
+
return decodeMessage(buf, Peer.codec(), opts);
|
|
373
|
+
}
|
|
374
|
+
Peer.decode = decode;
|
|
375
|
+
function stream(buf, opts) {
|
|
376
|
+
return streamMessage(buf, Peer.codec(), opts);
|
|
377
|
+
}
|
|
378
|
+
Peer.stream = stream;
|
|
220
379
|
})(Peer || (Peer = {}));
|
|
221
380
|
export var Reservation;
|
|
222
381
|
(function (Reservation) {
|
|
@@ -231,7 +390,7 @@ export var Reservation;
|
|
|
231
390
|
w.uint32(8);
|
|
232
391
|
w.uint64(obj.expire);
|
|
233
392
|
}
|
|
234
|
-
if (obj.addrs != null) {
|
|
393
|
+
if (obj.addrs != null && obj.addrs.length > 0) {
|
|
235
394
|
for (const value of obj.addrs) {
|
|
236
395
|
w.uint32(18);
|
|
237
396
|
w.bytes(value);
|
|
@@ -244,7 +403,7 @@ export var Reservation;
|
|
|
244
403
|
if (opts.lengthDelimited !== false) {
|
|
245
404
|
w.ldelim();
|
|
246
405
|
}
|
|
247
|
-
}, (reader, length) => {
|
|
406
|
+
}, (reader, length, opts = {}) => {
|
|
248
407
|
const obj = {
|
|
249
408
|
expire: 0n,
|
|
250
409
|
addrs: []
|
|
@@ -253,31 +412,84 @@ export var Reservation;
|
|
|
253
412
|
while (reader.pos < end) {
|
|
254
413
|
const tag = reader.uint32();
|
|
255
414
|
switch (tag >>> 3) {
|
|
256
|
-
case 1:
|
|
415
|
+
case 1: {
|
|
257
416
|
obj.expire = reader.uint64();
|
|
258
417
|
break;
|
|
259
|
-
|
|
418
|
+
}
|
|
419
|
+
case 2: {
|
|
420
|
+
if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
|
|
421
|
+
throw new MaxLengthError('Decode error - repeated field "addrs" had too many elements');
|
|
422
|
+
}
|
|
260
423
|
obj.addrs.push(reader.bytes());
|
|
261
424
|
break;
|
|
262
|
-
|
|
425
|
+
}
|
|
426
|
+
case 3: {
|
|
263
427
|
obj.voucher = reader.bytes();
|
|
264
428
|
break;
|
|
265
|
-
|
|
429
|
+
}
|
|
430
|
+
default: {
|
|
266
431
|
reader.skipType(tag & 7);
|
|
267
432
|
break;
|
|
433
|
+
}
|
|
268
434
|
}
|
|
269
435
|
}
|
|
270
436
|
return obj;
|
|
437
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
438
|
+
const obj = {
|
|
439
|
+
addrs: 0
|
|
440
|
+
};
|
|
441
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
442
|
+
while (reader.pos < end) {
|
|
443
|
+
const tag = reader.uint32();
|
|
444
|
+
switch (tag >>> 3) {
|
|
445
|
+
case 1: {
|
|
446
|
+
yield {
|
|
447
|
+
field: `${prefix}.expire`,
|
|
448
|
+
value: reader.uint64()
|
|
449
|
+
};
|
|
450
|
+
break;
|
|
451
|
+
}
|
|
452
|
+
case 2: {
|
|
453
|
+
if (opts.limits?.addrs != null && obj.addrs === opts.limits.addrs) {
|
|
454
|
+
throw new MaxLengthError('Streaming decode error - repeated field "addrs" had too many elements');
|
|
455
|
+
}
|
|
456
|
+
yield {
|
|
457
|
+
field: `${prefix}.addrs[]`,
|
|
458
|
+
index: obj.addrs,
|
|
459
|
+
value: reader.bytes()
|
|
460
|
+
};
|
|
461
|
+
obj.addrs++;
|
|
462
|
+
break;
|
|
463
|
+
}
|
|
464
|
+
case 3: {
|
|
465
|
+
yield {
|
|
466
|
+
field: `${prefix}.voucher`,
|
|
467
|
+
value: reader.bytes()
|
|
468
|
+
};
|
|
469
|
+
break;
|
|
470
|
+
}
|
|
471
|
+
default: {
|
|
472
|
+
reader.skipType(tag & 7);
|
|
473
|
+
break;
|
|
474
|
+
}
|
|
475
|
+
}
|
|
476
|
+
}
|
|
271
477
|
});
|
|
272
478
|
}
|
|
273
479
|
return _codec;
|
|
274
480
|
};
|
|
275
|
-
|
|
481
|
+
function encode(obj) {
|
|
276
482
|
return encodeMessage(obj, Reservation.codec());
|
|
277
|
-
}
|
|
278
|
-
Reservation.
|
|
279
|
-
|
|
280
|
-
|
|
483
|
+
}
|
|
484
|
+
Reservation.encode = encode;
|
|
485
|
+
function decode(buf, opts) {
|
|
486
|
+
return decodeMessage(buf, Reservation.codec(), opts);
|
|
487
|
+
}
|
|
488
|
+
Reservation.decode = decode;
|
|
489
|
+
function stream(buf, opts) {
|
|
490
|
+
return streamMessage(buf, Reservation.codec(), opts);
|
|
491
|
+
}
|
|
492
|
+
Reservation.stream = stream;
|
|
281
493
|
})(Reservation || (Reservation = {}));
|
|
282
494
|
export var Limit;
|
|
283
495
|
(function (Limit) {
|
|
@@ -299,34 +511,68 @@ export var Limit;
|
|
|
299
511
|
if (opts.lengthDelimited !== false) {
|
|
300
512
|
w.ldelim();
|
|
301
513
|
}
|
|
302
|
-
}, (reader, length) => {
|
|
514
|
+
}, (reader, length, opts = {}) => {
|
|
303
515
|
const obj = {};
|
|
304
516
|
const end = length == null ? reader.len : reader.pos + length;
|
|
305
517
|
while (reader.pos < end) {
|
|
306
518
|
const tag = reader.uint32();
|
|
307
519
|
switch (tag >>> 3) {
|
|
308
|
-
case 1:
|
|
520
|
+
case 1: {
|
|
309
521
|
obj.duration = reader.uint32();
|
|
310
522
|
break;
|
|
311
|
-
|
|
523
|
+
}
|
|
524
|
+
case 2: {
|
|
312
525
|
obj.data = reader.uint64();
|
|
313
526
|
break;
|
|
314
|
-
|
|
527
|
+
}
|
|
528
|
+
default: {
|
|
315
529
|
reader.skipType(tag & 7);
|
|
316
530
|
break;
|
|
531
|
+
}
|
|
317
532
|
}
|
|
318
533
|
}
|
|
319
534
|
return obj;
|
|
535
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
536
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
537
|
+
while (reader.pos < end) {
|
|
538
|
+
const tag = reader.uint32();
|
|
539
|
+
switch (tag >>> 3) {
|
|
540
|
+
case 1: {
|
|
541
|
+
yield {
|
|
542
|
+
field: `${prefix}.duration`,
|
|
543
|
+
value: reader.uint32()
|
|
544
|
+
};
|
|
545
|
+
break;
|
|
546
|
+
}
|
|
547
|
+
case 2: {
|
|
548
|
+
yield {
|
|
549
|
+
field: `${prefix}.data`,
|
|
550
|
+
value: reader.uint64()
|
|
551
|
+
};
|
|
552
|
+
break;
|
|
553
|
+
}
|
|
554
|
+
default: {
|
|
555
|
+
reader.skipType(tag & 7);
|
|
556
|
+
break;
|
|
557
|
+
}
|
|
558
|
+
}
|
|
559
|
+
}
|
|
320
560
|
});
|
|
321
561
|
}
|
|
322
562
|
return _codec;
|
|
323
563
|
};
|
|
324
|
-
|
|
564
|
+
function encode(obj) {
|
|
325
565
|
return encodeMessage(obj, Limit.codec());
|
|
326
|
-
}
|
|
327
|
-
Limit.
|
|
328
|
-
|
|
329
|
-
|
|
566
|
+
}
|
|
567
|
+
Limit.encode = encode;
|
|
568
|
+
function decode(buf, opts) {
|
|
569
|
+
return decodeMessage(buf, Limit.codec(), opts);
|
|
570
|
+
}
|
|
571
|
+
Limit.decode = decode;
|
|
572
|
+
function stream(buf, opts) {
|
|
573
|
+
return streamMessage(buf, Limit.codec(), opts);
|
|
574
|
+
}
|
|
575
|
+
Limit.stream = stream;
|
|
330
576
|
})(Limit || (Limit = {}));
|
|
331
577
|
export var Status;
|
|
332
578
|
(function (Status) {
|
|
@@ -381,40 +627,82 @@ export var ReservationVoucher;
|
|
|
381
627
|
if (opts.lengthDelimited !== false) {
|
|
382
628
|
w.ldelim();
|
|
383
629
|
}
|
|
384
|
-
}, (reader, length) => {
|
|
630
|
+
}, (reader, length, opts = {}) => {
|
|
385
631
|
const obj = {
|
|
386
|
-
relay:
|
|
387
|
-
peer:
|
|
632
|
+
relay: uint8ArrayAlloc(0),
|
|
633
|
+
peer: uint8ArrayAlloc(0),
|
|
388
634
|
expiration: 0n
|
|
389
635
|
};
|
|
390
636
|
const end = length == null ? reader.len : reader.pos + length;
|
|
391
637
|
while (reader.pos < end) {
|
|
392
638
|
const tag = reader.uint32();
|
|
393
639
|
switch (tag >>> 3) {
|
|
394
|
-
case 1:
|
|
640
|
+
case 1: {
|
|
395
641
|
obj.relay = reader.bytes();
|
|
396
642
|
break;
|
|
397
|
-
|
|
643
|
+
}
|
|
644
|
+
case 2: {
|
|
398
645
|
obj.peer = reader.bytes();
|
|
399
646
|
break;
|
|
400
|
-
|
|
647
|
+
}
|
|
648
|
+
case 3: {
|
|
401
649
|
obj.expiration = reader.uint64();
|
|
402
650
|
break;
|
|
403
|
-
|
|
651
|
+
}
|
|
652
|
+
default: {
|
|
404
653
|
reader.skipType(tag & 7);
|
|
405
654
|
break;
|
|
655
|
+
}
|
|
406
656
|
}
|
|
407
657
|
}
|
|
408
658
|
return obj;
|
|
659
|
+
}, function* (reader, length, prefix, opts = {}) {
|
|
660
|
+
const end = length == null ? reader.len : reader.pos + length;
|
|
661
|
+
while (reader.pos < end) {
|
|
662
|
+
const tag = reader.uint32();
|
|
663
|
+
switch (tag >>> 3) {
|
|
664
|
+
case 1: {
|
|
665
|
+
yield {
|
|
666
|
+
field: `${prefix}.relay`,
|
|
667
|
+
value: reader.bytes()
|
|
668
|
+
};
|
|
669
|
+
break;
|
|
670
|
+
}
|
|
671
|
+
case 2: {
|
|
672
|
+
yield {
|
|
673
|
+
field: `${prefix}.peer`,
|
|
674
|
+
value: reader.bytes()
|
|
675
|
+
};
|
|
676
|
+
break;
|
|
677
|
+
}
|
|
678
|
+
case 3: {
|
|
679
|
+
yield {
|
|
680
|
+
field: `${prefix}.expiration`,
|
|
681
|
+
value: reader.uint64()
|
|
682
|
+
};
|
|
683
|
+
break;
|
|
684
|
+
}
|
|
685
|
+
default: {
|
|
686
|
+
reader.skipType(tag & 7);
|
|
687
|
+
break;
|
|
688
|
+
}
|
|
689
|
+
}
|
|
690
|
+
}
|
|
409
691
|
});
|
|
410
692
|
}
|
|
411
693
|
return _codec;
|
|
412
694
|
};
|
|
413
|
-
|
|
695
|
+
function encode(obj) {
|
|
414
696
|
return encodeMessage(obj, ReservationVoucher.codec());
|
|
415
|
-
}
|
|
416
|
-
ReservationVoucher.
|
|
417
|
-
|
|
418
|
-
|
|
697
|
+
}
|
|
698
|
+
ReservationVoucher.encode = encode;
|
|
699
|
+
function decode(buf, opts) {
|
|
700
|
+
return decodeMessage(buf, ReservationVoucher.codec(), opts);
|
|
701
|
+
}
|
|
702
|
+
ReservationVoucher.decode = decode;
|
|
703
|
+
function stream(buf, opts) {
|
|
704
|
+
return streamMessage(buf, ReservationVoucher.codec(), opts);
|
|
705
|
+
}
|
|
706
|
+
ReservationVoucher.stream = stream;
|
|
419
707
|
})(ReservationVoucher || (ReservationVoucher = {}));
|
|
420
708
|
//# sourceMappingURL=index.js.map
|