@agoric/cosmic-proto 0.2.2-pismo-dev-0d5327f.0 → 0.3.1-dev-bf4b59f.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +22 -0
- package/README.md +5 -0
- package/dist/agoric/swingset/msgs.d.ts +450 -0
- package/dist/agoric/swingset/msgs.js +630 -0
- package/dist/agoric/swingset/query.d.ts +406 -0
- package/dist/agoric/swingset/query.js +346 -0
- package/dist/agoric/swingset/swingset.d.ts +571 -0
- package/dist/agoric/swingset/swingset.js +644 -0
- package/dist/cosmos/base/v1beta1/coin.d.ts +90 -0
- package/dist/cosmos/base/v1beta1/coin.js +197 -0
- package/package.json +23 -13
- package/swingset/msgs.js +2 -0
- package/swingset/query.js +2 -0
- package/swingset/swingset.js +2 -0
|
@@ -0,0 +1,644 @@
|
|
|
1
|
+
/* eslint-disable */
|
|
2
|
+
import Long from 'long';
|
|
3
|
+
import _m0 from 'protobufjs/minimal.js';
|
|
4
|
+
import { Coin } from '../../cosmos/base/v1beta1/coin.js';
|
|
5
|
+
export const protobufPackage = 'agoric.swingset';
|
|
6
|
+
function createBaseCoreEvalProposal() {
|
|
7
|
+
return { title: '', description: '', evals: [] };
|
|
8
|
+
}
|
|
9
|
+
export const CoreEvalProposal = {
|
|
10
|
+
encode(message, writer = _m0.Writer.create()) {
|
|
11
|
+
if (message.title !== '') {
|
|
12
|
+
writer.uint32(10).string(message.title);
|
|
13
|
+
}
|
|
14
|
+
if (message.description !== '') {
|
|
15
|
+
writer.uint32(18).string(message.description);
|
|
16
|
+
}
|
|
17
|
+
for (const v of message.evals) {
|
|
18
|
+
CoreEval.encode(v, writer.uint32(26).fork()).ldelim();
|
|
19
|
+
}
|
|
20
|
+
return writer;
|
|
21
|
+
},
|
|
22
|
+
decode(input, length) {
|
|
23
|
+
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
24
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
25
|
+
const message = createBaseCoreEvalProposal();
|
|
26
|
+
while (reader.pos < end) {
|
|
27
|
+
const tag = reader.uint32();
|
|
28
|
+
switch (tag >>> 3) {
|
|
29
|
+
case 1:
|
|
30
|
+
message.title = reader.string();
|
|
31
|
+
break;
|
|
32
|
+
case 2:
|
|
33
|
+
message.description = reader.string();
|
|
34
|
+
break;
|
|
35
|
+
case 3:
|
|
36
|
+
message.evals.push(CoreEval.decode(reader, reader.uint32()));
|
|
37
|
+
break;
|
|
38
|
+
default:
|
|
39
|
+
reader.skipType(tag & 7);
|
|
40
|
+
break;
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
return message;
|
|
44
|
+
},
|
|
45
|
+
fromJSON(object) {
|
|
46
|
+
return {
|
|
47
|
+
title: isSet(object.title) ? String(object.title) : '',
|
|
48
|
+
description: isSet(object.description) ? String(object.description) : '',
|
|
49
|
+
evals: Array.isArray(object?.evals)
|
|
50
|
+
? object.evals.map((e) => CoreEval.fromJSON(e))
|
|
51
|
+
: [],
|
|
52
|
+
};
|
|
53
|
+
},
|
|
54
|
+
toJSON(message) {
|
|
55
|
+
const obj = {};
|
|
56
|
+
message.title !== undefined && (obj.title = message.title);
|
|
57
|
+
message.description !== undefined &&
|
|
58
|
+
(obj.description = message.description);
|
|
59
|
+
if (message.evals) {
|
|
60
|
+
obj.evals = message.evals.map((e) =>
|
|
61
|
+
e ? CoreEval.toJSON(e) : undefined,
|
|
62
|
+
);
|
|
63
|
+
} else {
|
|
64
|
+
obj.evals = [];
|
|
65
|
+
}
|
|
66
|
+
return obj;
|
|
67
|
+
},
|
|
68
|
+
fromPartial(object) {
|
|
69
|
+
const message = createBaseCoreEvalProposal();
|
|
70
|
+
message.title = object.title ?? '';
|
|
71
|
+
message.description = object.description ?? '';
|
|
72
|
+
message.evals = object.evals?.map((e) => CoreEval.fromPartial(e)) || [];
|
|
73
|
+
return message;
|
|
74
|
+
},
|
|
75
|
+
};
|
|
76
|
+
function createBaseCoreEval() {
|
|
77
|
+
return { jsonPermits: '', jsCode: '' };
|
|
78
|
+
}
|
|
79
|
+
export const CoreEval = {
|
|
80
|
+
encode(message, writer = _m0.Writer.create()) {
|
|
81
|
+
if (message.jsonPermits !== '') {
|
|
82
|
+
writer.uint32(10).string(message.jsonPermits);
|
|
83
|
+
}
|
|
84
|
+
if (message.jsCode !== '') {
|
|
85
|
+
writer.uint32(18).string(message.jsCode);
|
|
86
|
+
}
|
|
87
|
+
return writer;
|
|
88
|
+
},
|
|
89
|
+
decode(input, length) {
|
|
90
|
+
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
91
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
92
|
+
const message = createBaseCoreEval();
|
|
93
|
+
while (reader.pos < end) {
|
|
94
|
+
const tag = reader.uint32();
|
|
95
|
+
switch (tag >>> 3) {
|
|
96
|
+
case 1:
|
|
97
|
+
message.jsonPermits = reader.string();
|
|
98
|
+
break;
|
|
99
|
+
case 2:
|
|
100
|
+
message.jsCode = reader.string();
|
|
101
|
+
break;
|
|
102
|
+
default:
|
|
103
|
+
reader.skipType(tag & 7);
|
|
104
|
+
break;
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
return message;
|
|
108
|
+
},
|
|
109
|
+
fromJSON(object) {
|
|
110
|
+
return {
|
|
111
|
+
jsonPermits: isSet(object.jsonPermits) ? String(object.jsonPermits) : '',
|
|
112
|
+
jsCode: isSet(object.jsCode) ? String(object.jsCode) : '',
|
|
113
|
+
};
|
|
114
|
+
},
|
|
115
|
+
toJSON(message) {
|
|
116
|
+
const obj = {};
|
|
117
|
+
message.jsonPermits !== undefined &&
|
|
118
|
+
(obj.jsonPermits = message.jsonPermits);
|
|
119
|
+
message.jsCode !== undefined && (obj.jsCode = message.jsCode);
|
|
120
|
+
return obj;
|
|
121
|
+
},
|
|
122
|
+
fromPartial(object) {
|
|
123
|
+
const message = createBaseCoreEval();
|
|
124
|
+
message.jsonPermits = object.jsonPermits ?? '';
|
|
125
|
+
message.jsCode = object.jsCode ?? '';
|
|
126
|
+
return message;
|
|
127
|
+
},
|
|
128
|
+
};
|
|
129
|
+
function createBaseParams() {
|
|
130
|
+
return {
|
|
131
|
+
beansPerUnit: [],
|
|
132
|
+
feeUnitPrice: [],
|
|
133
|
+
bootstrapVatConfig: '',
|
|
134
|
+
powerFlagFees: [],
|
|
135
|
+
queueMax: [],
|
|
136
|
+
};
|
|
137
|
+
}
|
|
138
|
+
export const Params = {
|
|
139
|
+
encode(message, writer = _m0.Writer.create()) {
|
|
140
|
+
for (const v of message.beansPerUnit) {
|
|
141
|
+
StringBeans.encode(v, writer.uint32(10).fork()).ldelim();
|
|
142
|
+
}
|
|
143
|
+
for (const v of message.feeUnitPrice) {
|
|
144
|
+
Coin.encode(v, writer.uint32(18).fork()).ldelim();
|
|
145
|
+
}
|
|
146
|
+
if (message.bootstrapVatConfig !== '') {
|
|
147
|
+
writer.uint32(26).string(message.bootstrapVatConfig);
|
|
148
|
+
}
|
|
149
|
+
for (const v of message.powerFlagFees) {
|
|
150
|
+
PowerFlagFee.encode(v, writer.uint32(34).fork()).ldelim();
|
|
151
|
+
}
|
|
152
|
+
for (const v of message.queueMax) {
|
|
153
|
+
QueueSize.encode(v, writer.uint32(42).fork()).ldelim();
|
|
154
|
+
}
|
|
155
|
+
return writer;
|
|
156
|
+
},
|
|
157
|
+
decode(input, length) {
|
|
158
|
+
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
159
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
160
|
+
const message = createBaseParams();
|
|
161
|
+
while (reader.pos < end) {
|
|
162
|
+
const tag = reader.uint32();
|
|
163
|
+
switch (tag >>> 3) {
|
|
164
|
+
case 1:
|
|
165
|
+
message.beansPerUnit.push(
|
|
166
|
+
StringBeans.decode(reader, reader.uint32()),
|
|
167
|
+
);
|
|
168
|
+
break;
|
|
169
|
+
case 2:
|
|
170
|
+
message.feeUnitPrice.push(Coin.decode(reader, reader.uint32()));
|
|
171
|
+
break;
|
|
172
|
+
case 3:
|
|
173
|
+
message.bootstrapVatConfig = reader.string();
|
|
174
|
+
break;
|
|
175
|
+
case 4:
|
|
176
|
+
message.powerFlagFees.push(
|
|
177
|
+
PowerFlagFee.decode(reader, reader.uint32()),
|
|
178
|
+
);
|
|
179
|
+
break;
|
|
180
|
+
case 5:
|
|
181
|
+
message.queueMax.push(QueueSize.decode(reader, reader.uint32()));
|
|
182
|
+
break;
|
|
183
|
+
default:
|
|
184
|
+
reader.skipType(tag & 7);
|
|
185
|
+
break;
|
|
186
|
+
}
|
|
187
|
+
}
|
|
188
|
+
return message;
|
|
189
|
+
},
|
|
190
|
+
fromJSON(object) {
|
|
191
|
+
return {
|
|
192
|
+
beansPerUnit: Array.isArray(object?.beansPerUnit)
|
|
193
|
+
? object.beansPerUnit.map((e) => StringBeans.fromJSON(e))
|
|
194
|
+
: [],
|
|
195
|
+
feeUnitPrice: Array.isArray(object?.feeUnitPrice)
|
|
196
|
+
? object.feeUnitPrice.map((e) => Coin.fromJSON(e))
|
|
197
|
+
: [],
|
|
198
|
+
bootstrapVatConfig: isSet(object.bootstrapVatConfig)
|
|
199
|
+
? String(object.bootstrapVatConfig)
|
|
200
|
+
: '',
|
|
201
|
+
powerFlagFees: Array.isArray(object?.powerFlagFees)
|
|
202
|
+
? object.powerFlagFees.map((e) => PowerFlagFee.fromJSON(e))
|
|
203
|
+
: [],
|
|
204
|
+
queueMax: Array.isArray(object?.queueMax)
|
|
205
|
+
? object.queueMax.map((e) => QueueSize.fromJSON(e))
|
|
206
|
+
: [],
|
|
207
|
+
};
|
|
208
|
+
},
|
|
209
|
+
toJSON(message) {
|
|
210
|
+
const obj = {};
|
|
211
|
+
if (message.beansPerUnit) {
|
|
212
|
+
obj.beansPerUnit = message.beansPerUnit.map((e) =>
|
|
213
|
+
e ? StringBeans.toJSON(e) : undefined,
|
|
214
|
+
);
|
|
215
|
+
} else {
|
|
216
|
+
obj.beansPerUnit = [];
|
|
217
|
+
}
|
|
218
|
+
if (message.feeUnitPrice) {
|
|
219
|
+
obj.feeUnitPrice = message.feeUnitPrice.map((e) =>
|
|
220
|
+
e ? Coin.toJSON(e) : undefined,
|
|
221
|
+
);
|
|
222
|
+
} else {
|
|
223
|
+
obj.feeUnitPrice = [];
|
|
224
|
+
}
|
|
225
|
+
message.bootstrapVatConfig !== undefined &&
|
|
226
|
+
(obj.bootstrapVatConfig = message.bootstrapVatConfig);
|
|
227
|
+
if (message.powerFlagFees) {
|
|
228
|
+
obj.powerFlagFees = message.powerFlagFees.map((e) =>
|
|
229
|
+
e ? PowerFlagFee.toJSON(e) : undefined,
|
|
230
|
+
);
|
|
231
|
+
} else {
|
|
232
|
+
obj.powerFlagFees = [];
|
|
233
|
+
}
|
|
234
|
+
if (message.queueMax) {
|
|
235
|
+
obj.queueMax = message.queueMax.map((e) =>
|
|
236
|
+
e ? QueueSize.toJSON(e) : undefined,
|
|
237
|
+
);
|
|
238
|
+
} else {
|
|
239
|
+
obj.queueMax = [];
|
|
240
|
+
}
|
|
241
|
+
return obj;
|
|
242
|
+
},
|
|
243
|
+
fromPartial(object) {
|
|
244
|
+
const message = createBaseParams();
|
|
245
|
+
message.beansPerUnit =
|
|
246
|
+
object.beansPerUnit?.map((e) => StringBeans.fromPartial(e)) || [];
|
|
247
|
+
message.feeUnitPrice =
|
|
248
|
+
object.feeUnitPrice?.map((e) => Coin.fromPartial(e)) || [];
|
|
249
|
+
message.bootstrapVatConfig = object.bootstrapVatConfig ?? '';
|
|
250
|
+
message.powerFlagFees =
|
|
251
|
+
object.powerFlagFees?.map((e) => PowerFlagFee.fromPartial(e)) || [];
|
|
252
|
+
message.queueMax =
|
|
253
|
+
object.queueMax?.map((e) => QueueSize.fromPartial(e)) || [];
|
|
254
|
+
return message;
|
|
255
|
+
},
|
|
256
|
+
};
|
|
257
|
+
function createBaseState() {
|
|
258
|
+
return { queueAllowed: [] };
|
|
259
|
+
}
|
|
260
|
+
export const State = {
|
|
261
|
+
encode(message, writer = _m0.Writer.create()) {
|
|
262
|
+
for (const v of message.queueAllowed) {
|
|
263
|
+
QueueSize.encode(v, writer.uint32(10).fork()).ldelim();
|
|
264
|
+
}
|
|
265
|
+
return writer;
|
|
266
|
+
},
|
|
267
|
+
decode(input, length) {
|
|
268
|
+
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
269
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
270
|
+
const message = createBaseState();
|
|
271
|
+
while (reader.pos < end) {
|
|
272
|
+
const tag = reader.uint32();
|
|
273
|
+
switch (tag >>> 3) {
|
|
274
|
+
case 1:
|
|
275
|
+
message.queueAllowed.push(QueueSize.decode(reader, reader.uint32()));
|
|
276
|
+
break;
|
|
277
|
+
default:
|
|
278
|
+
reader.skipType(tag & 7);
|
|
279
|
+
break;
|
|
280
|
+
}
|
|
281
|
+
}
|
|
282
|
+
return message;
|
|
283
|
+
},
|
|
284
|
+
fromJSON(object) {
|
|
285
|
+
return {
|
|
286
|
+
queueAllowed: Array.isArray(object?.queueAllowed)
|
|
287
|
+
? object.queueAllowed.map((e) => QueueSize.fromJSON(e))
|
|
288
|
+
: [],
|
|
289
|
+
};
|
|
290
|
+
},
|
|
291
|
+
toJSON(message) {
|
|
292
|
+
const obj = {};
|
|
293
|
+
if (message.queueAllowed) {
|
|
294
|
+
obj.queueAllowed = message.queueAllowed.map((e) =>
|
|
295
|
+
e ? QueueSize.toJSON(e) : undefined,
|
|
296
|
+
);
|
|
297
|
+
} else {
|
|
298
|
+
obj.queueAllowed = [];
|
|
299
|
+
}
|
|
300
|
+
return obj;
|
|
301
|
+
},
|
|
302
|
+
fromPartial(object) {
|
|
303
|
+
const message = createBaseState();
|
|
304
|
+
message.queueAllowed =
|
|
305
|
+
object.queueAllowed?.map((e) => QueueSize.fromPartial(e)) || [];
|
|
306
|
+
return message;
|
|
307
|
+
},
|
|
308
|
+
};
|
|
309
|
+
function createBaseStringBeans() {
|
|
310
|
+
return { key: '', beans: '' };
|
|
311
|
+
}
|
|
312
|
+
export const StringBeans = {
|
|
313
|
+
encode(message, writer = _m0.Writer.create()) {
|
|
314
|
+
if (message.key !== '') {
|
|
315
|
+
writer.uint32(10).string(message.key);
|
|
316
|
+
}
|
|
317
|
+
if (message.beans !== '') {
|
|
318
|
+
writer.uint32(18).string(message.beans);
|
|
319
|
+
}
|
|
320
|
+
return writer;
|
|
321
|
+
},
|
|
322
|
+
decode(input, length) {
|
|
323
|
+
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
324
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
325
|
+
const message = createBaseStringBeans();
|
|
326
|
+
while (reader.pos < end) {
|
|
327
|
+
const tag = reader.uint32();
|
|
328
|
+
switch (tag >>> 3) {
|
|
329
|
+
case 1:
|
|
330
|
+
message.key = reader.string();
|
|
331
|
+
break;
|
|
332
|
+
case 2:
|
|
333
|
+
message.beans = reader.string();
|
|
334
|
+
break;
|
|
335
|
+
default:
|
|
336
|
+
reader.skipType(tag & 7);
|
|
337
|
+
break;
|
|
338
|
+
}
|
|
339
|
+
}
|
|
340
|
+
return message;
|
|
341
|
+
},
|
|
342
|
+
fromJSON(object) {
|
|
343
|
+
return {
|
|
344
|
+
key: isSet(object.key) ? String(object.key) : '',
|
|
345
|
+
beans: isSet(object.beans) ? String(object.beans) : '',
|
|
346
|
+
};
|
|
347
|
+
},
|
|
348
|
+
toJSON(message) {
|
|
349
|
+
const obj = {};
|
|
350
|
+
message.key !== undefined && (obj.key = message.key);
|
|
351
|
+
message.beans !== undefined && (obj.beans = message.beans);
|
|
352
|
+
return obj;
|
|
353
|
+
},
|
|
354
|
+
fromPartial(object) {
|
|
355
|
+
const message = createBaseStringBeans();
|
|
356
|
+
message.key = object.key ?? '';
|
|
357
|
+
message.beans = object.beans ?? '';
|
|
358
|
+
return message;
|
|
359
|
+
},
|
|
360
|
+
};
|
|
361
|
+
function createBasePowerFlagFee() {
|
|
362
|
+
return { powerFlag: '', fee: [] };
|
|
363
|
+
}
|
|
364
|
+
export const PowerFlagFee = {
|
|
365
|
+
encode(message, writer = _m0.Writer.create()) {
|
|
366
|
+
if (message.powerFlag !== '') {
|
|
367
|
+
writer.uint32(10).string(message.powerFlag);
|
|
368
|
+
}
|
|
369
|
+
for (const v of message.fee) {
|
|
370
|
+
Coin.encode(v, writer.uint32(18).fork()).ldelim();
|
|
371
|
+
}
|
|
372
|
+
return writer;
|
|
373
|
+
},
|
|
374
|
+
decode(input, length) {
|
|
375
|
+
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
376
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
377
|
+
const message = createBasePowerFlagFee();
|
|
378
|
+
while (reader.pos < end) {
|
|
379
|
+
const tag = reader.uint32();
|
|
380
|
+
switch (tag >>> 3) {
|
|
381
|
+
case 1:
|
|
382
|
+
message.powerFlag = reader.string();
|
|
383
|
+
break;
|
|
384
|
+
case 2:
|
|
385
|
+
message.fee.push(Coin.decode(reader, reader.uint32()));
|
|
386
|
+
break;
|
|
387
|
+
default:
|
|
388
|
+
reader.skipType(tag & 7);
|
|
389
|
+
break;
|
|
390
|
+
}
|
|
391
|
+
}
|
|
392
|
+
return message;
|
|
393
|
+
},
|
|
394
|
+
fromJSON(object) {
|
|
395
|
+
return {
|
|
396
|
+
powerFlag: isSet(object.powerFlag) ? String(object.powerFlag) : '',
|
|
397
|
+
fee: Array.isArray(object?.fee)
|
|
398
|
+
? object.fee.map((e) => Coin.fromJSON(e))
|
|
399
|
+
: [],
|
|
400
|
+
};
|
|
401
|
+
},
|
|
402
|
+
toJSON(message) {
|
|
403
|
+
const obj = {};
|
|
404
|
+
message.powerFlag !== undefined && (obj.powerFlag = message.powerFlag);
|
|
405
|
+
if (message.fee) {
|
|
406
|
+
obj.fee = message.fee.map((e) => (e ? Coin.toJSON(e) : undefined));
|
|
407
|
+
} else {
|
|
408
|
+
obj.fee = [];
|
|
409
|
+
}
|
|
410
|
+
return obj;
|
|
411
|
+
},
|
|
412
|
+
fromPartial(object) {
|
|
413
|
+
const message = createBasePowerFlagFee();
|
|
414
|
+
message.powerFlag = object.powerFlag ?? '';
|
|
415
|
+
message.fee = object.fee?.map((e) => Coin.fromPartial(e)) || [];
|
|
416
|
+
return message;
|
|
417
|
+
},
|
|
418
|
+
};
|
|
419
|
+
function createBaseQueueSize() {
|
|
420
|
+
return { key: '', size: 0 };
|
|
421
|
+
}
|
|
422
|
+
export const QueueSize = {
|
|
423
|
+
encode(message, writer = _m0.Writer.create()) {
|
|
424
|
+
if (message.key !== '') {
|
|
425
|
+
writer.uint32(10).string(message.key);
|
|
426
|
+
}
|
|
427
|
+
if (message.size !== 0) {
|
|
428
|
+
writer.uint32(16).int32(message.size);
|
|
429
|
+
}
|
|
430
|
+
return writer;
|
|
431
|
+
},
|
|
432
|
+
decode(input, length) {
|
|
433
|
+
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
434
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
435
|
+
const message = createBaseQueueSize();
|
|
436
|
+
while (reader.pos < end) {
|
|
437
|
+
const tag = reader.uint32();
|
|
438
|
+
switch (tag >>> 3) {
|
|
439
|
+
case 1:
|
|
440
|
+
message.key = reader.string();
|
|
441
|
+
break;
|
|
442
|
+
case 2:
|
|
443
|
+
message.size = reader.int32();
|
|
444
|
+
break;
|
|
445
|
+
default:
|
|
446
|
+
reader.skipType(tag & 7);
|
|
447
|
+
break;
|
|
448
|
+
}
|
|
449
|
+
}
|
|
450
|
+
return message;
|
|
451
|
+
},
|
|
452
|
+
fromJSON(object) {
|
|
453
|
+
return {
|
|
454
|
+
key: isSet(object.key) ? String(object.key) : '',
|
|
455
|
+
size: isSet(object.size) ? Number(object.size) : 0,
|
|
456
|
+
};
|
|
457
|
+
},
|
|
458
|
+
toJSON(message) {
|
|
459
|
+
const obj = {};
|
|
460
|
+
message.key !== undefined && (obj.key = message.key);
|
|
461
|
+
message.size !== undefined && (obj.size = Math.round(message.size));
|
|
462
|
+
return obj;
|
|
463
|
+
},
|
|
464
|
+
fromPartial(object) {
|
|
465
|
+
const message = createBaseQueueSize();
|
|
466
|
+
message.key = object.key ?? '';
|
|
467
|
+
message.size = object.size ?? 0;
|
|
468
|
+
return message;
|
|
469
|
+
},
|
|
470
|
+
};
|
|
471
|
+
function createBaseEgress() {
|
|
472
|
+
return { nickname: '', peer: new Uint8Array(), powerFlags: [] };
|
|
473
|
+
}
|
|
474
|
+
export const Egress = {
|
|
475
|
+
encode(message, writer = _m0.Writer.create()) {
|
|
476
|
+
if (message.nickname !== '') {
|
|
477
|
+
writer.uint32(10).string(message.nickname);
|
|
478
|
+
}
|
|
479
|
+
if (message.peer.length !== 0) {
|
|
480
|
+
writer.uint32(18).bytes(message.peer);
|
|
481
|
+
}
|
|
482
|
+
for (const v of message.powerFlags) {
|
|
483
|
+
writer.uint32(26).string(v);
|
|
484
|
+
}
|
|
485
|
+
return writer;
|
|
486
|
+
},
|
|
487
|
+
decode(input, length) {
|
|
488
|
+
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
489
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
490
|
+
const message = createBaseEgress();
|
|
491
|
+
while (reader.pos < end) {
|
|
492
|
+
const tag = reader.uint32();
|
|
493
|
+
switch (tag >>> 3) {
|
|
494
|
+
case 1:
|
|
495
|
+
message.nickname = reader.string();
|
|
496
|
+
break;
|
|
497
|
+
case 2:
|
|
498
|
+
message.peer = reader.bytes();
|
|
499
|
+
break;
|
|
500
|
+
case 3:
|
|
501
|
+
message.powerFlags.push(reader.string());
|
|
502
|
+
break;
|
|
503
|
+
default:
|
|
504
|
+
reader.skipType(tag & 7);
|
|
505
|
+
break;
|
|
506
|
+
}
|
|
507
|
+
}
|
|
508
|
+
return message;
|
|
509
|
+
},
|
|
510
|
+
fromJSON(object) {
|
|
511
|
+
return {
|
|
512
|
+
nickname: isSet(object.nickname) ? String(object.nickname) : '',
|
|
513
|
+
peer: isSet(object.peer)
|
|
514
|
+
? bytesFromBase64(object.peer)
|
|
515
|
+
: new Uint8Array(),
|
|
516
|
+
powerFlags: Array.isArray(object?.powerFlags)
|
|
517
|
+
? object.powerFlags.map((e) => String(e))
|
|
518
|
+
: [],
|
|
519
|
+
};
|
|
520
|
+
},
|
|
521
|
+
toJSON(message) {
|
|
522
|
+
const obj = {};
|
|
523
|
+
message.nickname !== undefined && (obj.nickname = message.nickname);
|
|
524
|
+
message.peer !== undefined &&
|
|
525
|
+
(obj.peer = base64FromBytes(
|
|
526
|
+
message.peer !== undefined ? message.peer : new Uint8Array(),
|
|
527
|
+
));
|
|
528
|
+
if (message.powerFlags) {
|
|
529
|
+
obj.powerFlags = message.powerFlags.map((e) => e);
|
|
530
|
+
} else {
|
|
531
|
+
obj.powerFlags = [];
|
|
532
|
+
}
|
|
533
|
+
return obj;
|
|
534
|
+
},
|
|
535
|
+
fromPartial(object) {
|
|
536
|
+
const message = createBaseEgress();
|
|
537
|
+
message.nickname = object.nickname ?? '';
|
|
538
|
+
message.peer = object.peer ?? new Uint8Array();
|
|
539
|
+
message.powerFlags = object.powerFlags?.map((e) => e) || [];
|
|
540
|
+
return message;
|
|
541
|
+
},
|
|
542
|
+
};
|
|
543
|
+
function createBaseExtensionSnapshotterArtifactPayload() {
|
|
544
|
+
return { name: '', data: new Uint8Array() };
|
|
545
|
+
}
|
|
546
|
+
export const ExtensionSnapshotterArtifactPayload = {
|
|
547
|
+
encode(message, writer = _m0.Writer.create()) {
|
|
548
|
+
if (message.name !== '') {
|
|
549
|
+
writer.uint32(10).string(message.name);
|
|
550
|
+
}
|
|
551
|
+
if (message.data.length !== 0) {
|
|
552
|
+
writer.uint32(18).bytes(message.data);
|
|
553
|
+
}
|
|
554
|
+
return writer;
|
|
555
|
+
},
|
|
556
|
+
decode(input, length) {
|
|
557
|
+
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
558
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
559
|
+
const message = createBaseExtensionSnapshotterArtifactPayload();
|
|
560
|
+
while (reader.pos < end) {
|
|
561
|
+
const tag = reader.uint32();
|
|
562
|
+
switch (tag >>> 3) {
|
|
563
|
+
case 1:
|
|
564
|
+
message.name = reader.string();
|
|
565
|
+
break;
|
|
566
|
+
case 2:
|
|
567
|
+
message.data = reader.bytes();
|
|
568
|
+
break;
|
|
569
|
+
default:
|
|
570
|
+
reader.skipType(tag & 7);
|
|
571
|
+
break;
|
|
572
|
+
}
|
|
573
|
+
}
|
|
574
|
+
return message;
|
|
575
|
+
},
|
|
576
|
+
fromJSON(object) {
|
|
577
|
+
return {
|
|
578
|
+
name: isSet(object.name) ? String(object.name) : '',
|
|
579
|
+
data: isSet(object.data)
|
|
580
|
+
? bytesFromBase64(object.data)
|
|
581
|
+
: new Uint8Array(),
|
|
582
|
+
};
|
|
583
|
+
},
|
|
584
|
+
toJSON(message) {
|
|
585
|
+
const obj = {};
|
|
586
|
+
message.name !== undefined && (obj.name = message.name);
|
|
587
|
+
message.data !== undefined &&
|
|
588
|
+
(obj.data = base64FromBytes(
|
|
589
|
+
message.data !== undefined ? message.data : new Uint8Array(),
|
|
590
|
+
));
|
|
591
|
+
return obj;
|
|
592
|
+
},
|
|
593
|
+
fromPartial(object) {
|
|
594
|
+
const message = createBaseExtensionSnapshotterArtifactPayload();
|
|
595
|
+
message.name = object.name ?? '';
|
|
596
|
+
message.data = object.data ?? new Uint8Array();
|
|
597
|
+
return message;
|
|
598
|
+
},
|
|
599
|
+
};
|
|
600
|
+
var globalThis = (() => {
|
|
601
|
+
if (typeof globalThis !== 'undefined') {
|
|
602
|
+
return globalThis;
|
|
603
|
+
}
|
|
604
|
+
if (typeof self !== 'undefined') {
|
|
605
|
+
return self;
|
|
606
|
+
}
|
|
607
|
+
if (typeof window !== 'undefined') {
|
|
608
|
+
return window;
|
|
609
|
+
}
|
|
610
|
+
if (typeof global !== 'undefined') {
|
|
611
|
+
return global;
|
|
612
|
+
}
|
|
613
|
+
throw 'Unable to locate global object';
|
|
614
|
+
})();
|
|
615
|
+
function bytesFromBase64(b64) {
|
|
616
|
+
if (globalThis.Buffer) {
|
|
617
|
+
return Uint8Array.from(globalThis.Buffer.from(b64, 'base64'));
|
|
618
|
+
} else {
|
|
619
|
+
const bin = globalThis.atob(b64);
|
|
620
|
+
const arr = new Uint8Array(bin.length);
|
|
621
|
+
for (let i = 0; i < bin.length; ++i) {
|
|
622
|
+
arr[i] = bin.charCodeAt(i);
|
|
623
|
+
}
|
|
624
|
+
return arr;
|
|
625
|
+
}
|
|
626
|
+
}
|
|
627
|
+
function base64FromBytes(arr) {
|
|
628
|
+
if (globalThis.Buffer) {
|
|
629
|
+
return globalThis.Buffer.from(arr).toString('base64');
|
|
630
|
+
} else {
|
|
631
|
+
const bin = [];
|
|
632
|
+
arr.forEach((byte) => {
|
|
633
|
+
bin.push(String.fromCharCode(byte));
|
|
634
|
+
});
|
|
635
|
+
return globalThis.btoa(bin.join(''));
|
|
636
|
+
}
|
|
637
|
+
}
|
|
638
|
+
if (_m0.util.Long !== Long) {
|
|
639
|
+
_m0.util.Long = Long;
|
|
640
|
+
_m0.configure();
|
|
641
|
+
}
|
|
642
|
+
function isSet(value) {
|
|
643
|
+
return value !== null && value !== undefined;
|
|
644
|
+
}
|