@latticexyz/services 2.0.0-snapshot-test-32d38619 → 2.0.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.
@@ -1,1078 +0,0 @@
1
- /* eslint-disable */
2
- import Long from "long";
3
- import type { CallContext, CallOptions } from "nice-grpc-common";
4
- import _m0 from "protobufjs/minimal.js";
5
-
6
- export const protobufPackage = "ecssnapshot";
7
-
8
- export interface ECSState {
9
- componentIdIdx: number;
10
- entityIdIdx: number;
11
- value: Uint8Array;
12
- }
13
-
14
- export interface ECSStateSnapshot {
15
- state: ECSState[];
16
- stateComponents: string[];
17
- stateEntities: string[];
18
- stateHash: string;
19
- startBlockNumber: number;
20
- endBlockNumber: number;
21
- worldAddress: string;
22
- }
23
-
24
- export interface Worlds {
25
- worldAddress: string[];
26
- }
27
-
28
- /** The request message for the latest ECS state. */
29
- export interface ECSStateRequestLatest {
30
- worldAddress: string;
31
- }
32
-
33
- /** The request message for the latest ECS statem, pruned for specific address. */
34
- export interface ECSStateRequestLatestStreamPruned {
35
- worldAddress: string;
36
- pruneAddress: string;
37
- pruneComponentId?: string | undefined;
38
- chunkPercentage?: number | undefined;
39
- }
40
-
41
- /** The request message for the latest chunked ECS state. */
42
- export interface ECSStateRequestLatestStream {
43
- worldAddress: string;
44
- chunkPercentage?: number | undefined;
45
- }
46
-
47
- /** The request message for the latest block based on latest ECS state. */
48
- export interface ECSStateBlockRequestLatest {
49
- worldAddress: string;
50
- }
51
-
52
- /** The request message for the ECS state given a block number. */
53
- export interface ECSStateRequestAtBlock {
54
- blockNumber: number;
55
- }
56
-
57
- /** The request message for all worlds. */
58
- export interface WorldsRequest {}
59
-
60
- /** The response message containing the current state, hash of that state, and the block number of that state. */
61
- export interface ECSStateReply {
62
- state: ECSState[];
63
- stateComponents: string[];
64
- stateEntities: string[];
65
- stateHash: string;
66
- blockNumber: number;
67
- }
68
-
69
- export interface ECSStateReplyV2 {
70
- state: ECSState[];
71
- stateComponents: string[];
72
- stateEntities: Uint8Array[];
73
- stateHash: string;
74
- blockNumber: number;
75
- }
76
-
77
- export interface ECSStateBlockReply {
78
- blockNumber: number;
79
- }
80
-
81
- function createBaseECSState(): ECSState {
82
- return { componentIdIdx: 0, entityIdIdx: 0, value: new Uint8Array() };
83
- }
84
-
85
- export const ECSState = {
86
- encode(message: ECSState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
87
- if (message.componentIdIdx !== 0) {
88
- writer.uint32(8).uint32(message.componentIdIdx);
89
- }
90
- if (message.entityIdIdx !== 0) {
91
- writer.uint32(16).uint32(message.entityIdIdx);
92
- }
93
- if (message.value.length !== 0) {
94
- writer.uint32(26).bytes(message.value);
95
- }
96
- return writer;
97
- },
98
-
99
- decode(input: _m0.Reader | Uint8Array, length?: number): ECSState {
100
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
101
- let end = length === undefined ? reader.len : reader.pos + length;
102
- const message = createBaseECSState();
103
- while (reader.pos < end) {
104
- const tag = reader.uint32();
105
- switch (tag >>> 3) {
106
- case 1:
107
- if (tag != 8) {
108
- break;
109
- }
110
-
111
- message.componentIdIdx = reader.uint32();
112
- continue;
113
- case 2:
114
- if (tag != 16) {
115
- break;
116
- }
117
-
118
- message.entityIdIdx = reader.uint32();
119
- continue;
120
- case 3:
121
- if (tag != 26) {
122
- break;
123
- }
124
-
125
- message.value = reader.bytes();
126
- continue;
127
- }
128
- if ((tag & 7) == 4 || tag == 0) {
129
- break;
130
- }
131
- reader.skipType(tag & 7);
132
- }
133
- return message;
134
- },
135
-
136
- create(base?: DeepPartial<ECSState>): ECSState {
137
- return ECSState.fromPartial(base ?? {});
138
- },
139
-
140
- fromPartial(object: DeepPartial<ECSState>): ECSState {
141
- const message = createBaseECSState();
142
- message.componentIdIdx = object.componentIdIdx ?? 0;
143
- message.entityIdIdx = object.entityIdIdx ?? 0;
144
- message.value = object.value ?? new Uint8Array();
145
- return message;
146
- },
147
- };
148
-
149
- function createBaseECSStateSnapshot(): ECSStateSnapshot {
150
- return {
151
- state: [],
152
- stateComponents: [],
153
- stateEntities: [],
154
- stateHash: "",
155
- startBlockNumber: 0,
156
- endBlockNumber: 0,
157
- worldAddress: "",
158
- };
159
- }
160
-
161
- export const ECSStateSnapshot = {
162
- encode(message: ECSStateSnapshot, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
163
- for (const v of message.state) {
164
- ECSState.encode(v!, writer.uint32(10).fork()).ldelim();
165
- }
166
- for (const v of message.stateComponents) {
167
- writer.uint32(18).string(v!);
168
- }
169
- for (const v of message.stateEntities) {
170
- writer.uint32(26).string(v!);
171
- }
172
- if (message.stateHash !== "") {
173
- writer.uint32(34).string(message.stateHash);
174
- }
175
- if (message.startBlockNumber !== 0) {
176
- writer.uint32(40).uint32(message.startBlockNumber);
177
- }
178
- if (message.endBlockNumber !== 0) {
179
- writer.uint32(48).uint32(message.endBlockNumber);
180
- }
181
- if (message.worldAddress !== "") {
182
- writer.uint32(58).string(message.worldAddress);
183
- }
184
- return writer;
185
- },
186
-
187
- decode(input: _m0.Reader | Uint8Array, length?: number): ECSStateSnapshot {
188
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
189
- let end = length === undefined ? reader.len : reader.pos + length;
190
- const message = createBaseECSStateSnapshot();
191
- while (reader.pos < end) {
192
- const tag = reader.uint32();
193
- switch (tag >>> 3) {
194
- case 1:
195
- if (tag != 10) {
196
- break;
197
- }
198
-
199
- message.state.push(ECSState.decode(reader, reader.uint32()));
200
- continue;
201
- case 2:
202
- if (tag != 18) {
203
- break;
204
- }
205
-
206
- message.stateComponents.push(reader.string());
207
- continue;
208
- case 3:
209
- if (tag != 26) {
210
- break;
211
- }
212
-
213
- message.stateEntities.push(reader.string());
214
- continue;
215
- case 4:
216
- if (tag != 34) {
217
- break;
218
- }
219
-
220
- message.stateHash = reader.string();
221
- continue;
222
- case 5:
223
- if (tag != 40) {
224
- break;
225
- }
226
-
227
- message.startBlockNumber = reader.uint32();
228
- continue;
229
- case 6:
230
- if (tag != 48) {
231
- break;
232
- }
233
-
234
- message.endBlockNumber = reader.uint32();
235
- continue;
236
- case 7:
237
- if (tag != 58) {
238
- break;
239
- }
240
-
241
- message.worldAddress = reader.string();
242
- continue;
243
- }
244
- if ((tag & 7) == 4 || tag == 0) {
245
- break;
246
- }
247
- reader.skipType(tag & 7);
248
- }
249
- return message;
250
- },
251
-
252
- create(base?: DeepPartial<ECSStateSnapshot>): ECSStateSnapshot {
253
- return ECSStateSnapshot.fromPartial(base ?? {});
254
- },
255
-
256
- fromPartial(object: DeepPartial<ECSStateSnapshot>): ECSStateSnapshot {
257
- const message = createBaseECSStateSnapshot();
258
- message.state = object.state?.map((e) => ECSState.fromPartial(e)) || [];
259
- message.stateComponents = object.stateComponents?.map((e) => e) || [];
260
- message.stateEntities = object.stateEntities?.map((e) => e) || [];
261
- message.stateHash = object.stateHash ?? "";
262
- message.startBlockNumber = object.startBlockNumber ?? 0;
263
- message.endBlockNumber = object.endBlockNumber ?? 0;
264
- message.worldAddress = object.worldAddress ?? "";
265
- return message;
266
- },
267
- };
268
-
269
- function createBaseWorlds(): Worlds {
270
- return { worldAddress: [] };
271
- }
272
-
273
- export const Worlds = {
274
- encode(message: Worlds, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
275
- for (const v of message.worldAddress) {
276
- writer.uint32(10).string(v!);
277
- }
278
- return writer;
279
- },
280
-
281
- decode(input: _m0.Reader | Uint8Array, length?: number): Worlds {
282
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
283
- let end = length === undefined ? reader.len : reader.pos + length;
284
- const message = createBaseWorlds();
285
- while (reader.pos < end) {
286
- const tag = reader.uint32();
287
- switch (tag >>> 3) {
288
- case 1:
289
- if (tag != 10) {
290
- break;
291
- }
292
-
293
- message.worldAddress.push(reader.string());
294
- continue;
295
- }
296
- if ((tag & 7) == 4 || tag == 0) {
297
- break;
298
- }
299
- reader.skipType(tag & 7);
300
- }
301
- return message;
302
- },
303
-
304
- create(base?: DeepPartial<Worlds>): Worlds {
305
- return Worlds.fromPartial(base ?? {});
306
- },
307
-
308
- fromPartial(object: DeepPartial<Worlds>): Worlds {
309
- const message = createBaseWorlds();
310
- message.worldAddress = object.worldAddress?.map((e) => e) || [];
311
- return message;
312
- },
313
- };
314
-
315
- function createBaseECSStateRequestLatest(): ECSStateRequestLatest {
316
- return { worldAddress: "" };
317
- }
318
-
319
- export const ECSStateRequestLatest = {
320
- encode(message: ECSStateRequestLatest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
321
- if (message.worldAddress !== "") {
322
- writer.uint32(10).string(message.worldAddress);
323
- }
324
- return writer;
325
- },
326
-
327
- decode(input: _m0.Reader | Uint8Array, length?: number): ECSStateRequestLatest {
328
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
329
- let end = length === undefined ? reader.len : reader.pos + length;
330
- const message = createBaseECSStateRequestLatest();
331
- while (reader.pos < end) {
332
- const tag = reader.uint32();
333
- switch (tag >>> 3) {
334
- case 1:
335
- if (tag != 10) {
336
- break;
337
- }
338
-
339
- message.worldAddress = reader.string();
340
- continue;
341
- }
342
- if ((tag & 7) == 4 || tag == 0) {
343
- break;
344
- }
345
- reader.skipType(tag & 7);
346
- }
347
- return message;
348
- },
349
-
350
- create(base?: DeepPartial<ECSStateRequestLatest>): ECSStateRequestLatest {
351
- return ECSStateRequestLatest.fromPartial(base ?? {});
352
- },
353
-
354
- fromPartial(object: DeepPartial<ECSStateRequestLatest>): ECSStateRequestLatest {
355
- const message = createBaseECSStateRequestLatest();
356
- message.worldAddress = object.worldAddress ?? "";
357
- return message;
358
- },
359
- };
360
-
361
- function createBaseECSStateRequestLatestStreamPruned(): ECSStateRequestLatestStreamPruned {
362
- return { worldAddress: "", pruneAddress: "", pruneComponentId: undefined, chunkPercentage: undefined };
363
- }
364
-
365
- export const ECSStateRequestLatestStreamPruned = {
366
- encode(message: ECSStateRequestLatestStreamPruned, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
367
- if (message.worldAddress !== "") {
368
- writer.uint32(10).string(message.worldAddress);
369
- }
370
- if (message.pruneAddress !== "") {
371
- writer.uint32(18).string(message.pruneAddress);
372
- }
373
- if (message.pruneComponentId !== undefined) {
374
- writer.uint32(26).string(message.pruneComponentId);
375
- }
376
- if (message.chunkPercentage !== undefined) {
377
- writer.uint32(32).uint32(message.chunkPercentage);
378
- }
379
- return writer;
380
- },
381
-
382
- decode(input: _m0.Reader | Uint8Array, length?: number): ECSStateRequestLatestStreamPruned {
383
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
384
- let end = length === undefined ? reader.len : reader.pos + length;
385
- const message = createBaseECSStateRequestLatestStreamPruned();
386
- while (reader.pos < end) {
387
- const tag = reader.uint32();
388
- switch (tag >>> 3) {
389
- case 1:
390
- if (tag != 10) {
391
- break;
392
- }
393
-
394
- message.worldAddress = reader.string();
395
- continue;
396
- case 2:
397
- if (tag != 18) {
398
- break;
399
- }
400
-
401
- message.pruneAddress = reader.string();
402
- continue;
403
- case 3:
404
- if (tag != 26) {
405
- break;
406
- }
407
-
408
- message.pruneComponentId = reader.string();
409
- continue;
410
- case 4:
411
- if (tag != 32) {
412
- break;
413
- }
414
-
415
- message.chunkPercentage = reader.uint32();
416
- continue;
417
- }
418
- if ((tag & 7) == 4 || tag == 0) {
419
- break;
420
- }
421
- reader.skipType(tag & 7);
422
- }
423
- return message;
424
- },
425
-
426
- create(base?: DeepPartial<ECSStateRequestLatestStreamPruned>): ECSStateRequestLatestStreamPruned {
427
- return ECSStateRequestLatestStreamPruned.fromPartial(base ?? {});
428
- },
429
-
430
- fromPartial(object: DeepPartial<ECSStateRequestLatestStreamPruned>): ECSStateRequestLatestStreamPruned {
431
- const message = createBaseECSStateRequestLatestStreamPruned();
432
- message.worldAddress = object.worldAddress ?? "";
433
- message.pruneAddress = object.pruneAddress ?? "";
434
- message.pruneComponentId = object.pruneComponentId ?? undefined;
435
- message.chunkPercentage = object.chunkPercentage ?? undefined;
436
- return message;
437
- },
438
- };
439
-
440
- function createBaseECSStateRequestLatestStream(): ECSStateRequestLatestStream {
441
- return { worldAddress: "", chunkPercentage: undefined };
442
- }
443
-
444
- export const ECSStateRequestLatestStream = {
445
- encode(message: ECSStateRequestLatestStream, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
446
- if (message.worldAddress !== "") {
447
- writer.uint32(10).string(message.worldAddress);
448
- }
449
- if (message.chunkPercentage !== undefined) {
450
- writer.uint32(16).uint32(message.chunkPercentage);
451
- }
452
- return writer;
453
- },
454
-
455
- decode(input: _m0.Reader | Uint8Array, length?: number): ECSStateRequestLatestStream {
456
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
457
- let end = length === undefined ? reader.len : reader.pos + length;
458
- const message = createBaseECSStateRequestLatestStream();
459
- while (reader.pos < end) {
460
- const tag = reader.uint32();
461
- switch (tag >>> 3) {
462
- case 1:
463
- if (tag != 10) {
464
- break;
465
- }
466
-
467
- message.worldAddress = reader.string();
468
- continue;
469
- case 2:
470
- if (tag != 16) {
471
- break;
472
- }
473
-
474
- message.chunkPercentage = reader.uint32();
475
- continue;
476
- }
477
- if ((tag & 7) == 4 || tag == 0) {
478
- break;
479
- }
480
- reader.skipType(tag & 7);
481
- }
482
- return message;
483
- },
484
-
485
- create(base?: DeepPartial<ECSStateRequestLatestStream>): ECSStateRequestLatestStream {
486
- return ECSStateRequestLatestStream.fromPartial(base ?? {});
487
- },
488
-
489
- fromPartial(object: DeepPartial<ECSStateRequestLatestStream>): ECSStateRequestLatestStream {
490
- const message = createBaseECSStateRequestLatestStream();
491
- message.worldAddress = object.worldAddress ?? "";
492
- message.chunkPercentage = object.chunkPercentage ?? undefined;
493
- return message;
494
- },
495
- };
496
-
497
- function createBaseECSStateBlockRequestLatest(): ECSStateBlockRequestLatest {
498
- return { worldAddress: "" };
499
- }
500
-
501
- export const ECSStateBlockRequestLatest = {
502
- encode(message: ECSStateBlockRequestLatest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
503
- if (message.worldAddress !== "") {
504
- writer.uint32(10).string(message.worldAddress);
505
- }
506
- return writer;
507
- },
508
-
509
- decode(input: _m0.Reader | Uint8Array, length?: number): ECSStateBlockRequestLatest {
510
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
511
- let end = length === undefined ? reader.len : reader.pos + length;
512
- const message = createBaseECSStateBlockRequestLatest();
513
- while (reader.pos < end) {
514
- const tag = reader.uint32();
515
- switch (tag >>> 3) {
516
- case 1:
517
- if (tag != 10) {
518
- break;
519
- }
520
-
521
- message.worldAddress = reader.string();
522
- continue;
523
- }
524
- if ((tag & 7) == 4 || tag == 0) {
525
- break;
526
- }
527
- reader.skipType(tag & 7);
528
- }
529
- return message;
530
- },
531
-
532
- create(base?: DeepPartial<ECSStateBlockRequestLatest>): ECSStateBlockRequestLatest {
533
- return ECSStateBlockRequestLatest.fromPartial(base ?? {});
534
- },
535
-
536
- fromPartial(object: DeepPartial<ECSStateBlockRequestLatest>): ECSStateBlockRequestLatest {
537
- const message = createBaseECSStateBlockRequestLatest();
538
- message.worldAddress = object.worldAddress ?? "";
539
- return message;
540
- },
541
- };
542
-
543
- function createBaseECSStateRequestAtBlock(): ECSStateRequestAtBlock {
544
- return { blockNumber: 0 };
545
- }
546
-
547
- export const ECSStateRequestAtBlock = {
548
- encode(message: ECSStateRequestAtBlock, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
549
- if (message.blockNumber !== 0) {
550
- writer.uint32(8).uint64(message.blockNumber);
551
- }
552
- return writer;
553
- },
554
-
555
- decode(input: _m0.Reader | Uint8Array, length?: number): ECSStateRequestAtBlock {
556
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
557
- let end = length === undefined ? reader.len : reader.pos + length;
558
- const message = createBaseECSStateRequestAtBlock();
559
- while (reader.pos < end) {
560
- const tag = reader.uint32();
561
- switch (tag >>> 3) {
562
- case 1:
563
- if (tag != 8) {
564
- break;
565
- }
566
-
567
- message.blockNumber = longToNumber(reader.uint64() as Long);
568
- continue;
569
- }
570
- if ((tag & 7) == 4 || tag == 0) {
571
- break;
572
- }
573
- reader.skipType(tag & 7);
574
- }
575
- return message;
576
- },
577
-
578
- create(base?: DeepPartial<ECSStateRequestAtBlock>): ECSStateRequestAtBlock {
579
- return ECSStateRequestAtBlock.fromPartial(base ?? {});
580
- },
581
-
582
- fromPartial(object: DeepPartial<ECSStateRequestAtBlock>): ECSStateRequestAtBlock {
583
- const message = createBaseECSStateRequestAtBlock();
584
- message.blockNumber = object.blockNumber ?? 0;
585
- return message;
586
- },
587
- };
588
-
589
- function createBaseWorldsRequest(): WorldsRequest {
590
- return {};
591
- }
592
-
593
- export const WorldsRequest = {
594
- encode(_: WorldsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
595
- return writer;
596
- },
597
-
598
- decode(input: _m0.Reader | Uint8Array, length?: number): WorldsRequest {
599
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
600
- let end = length === undefined ? reader.len : reader.pos + length;
601
- const message = createBaseWorldsRequest();
602
- while (reader.pos < end) {
603
- const tag = reader.uint32();
604
- switch (tag >>> 3) {
605
- }
606
- if ((tag & 7) == 4 || tag == 0) {
607
- break;
608
- }
609
- reader.skipType(tag & 7);
610
- }
611
- return message;
612
- },
613
-
614
- create(base?: DeepPartial<WorldsRequest>): WorldsRequest {
615
- return WorldsRequest.fromPartial(base ?? {});
616
- },
617
-
618
- fromPartial(_: DeepPartial<WorldsRequest>): WorldsRequest {
619
- const message = createBaseWorldsRequest();
620
- return message;
621
- },
622
- };
623
-
624
- function createBaseECSStateReply(): ECSStateReply {
625
- return { state: [], stateComponents: [], stateEntities: [], stateHash: "", blockNumber: 0 };
626
- }
627
-
628
- export const ECSStateReply = {
629
- encode(message: ECSStateReply, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
630
- for (const v of message.state) {
631
- ECSState.encode(v!, writer.uint32(10).fork()).ldelim();
632
- }
633
- for (const v of message.stateComponents) {
634
- writer.uint32(18).string(v!);
635
- }
636
- for (const v of message.stateEntities) {
637
- writer.uint32(26).string(v!);
638
- }
639
- if (message.stateHash !== "") {
640
- writer.uint32(34).string(message.stateHash);
641
- }
642
- if (message.blockNumber !== 0) {
643
- writer.uint32(40).uint32(message.blockNumber);
644
- }
645
- return writer;
646
- },
647
-
648
- decode(input: _m0.Reader | Uint8Array, length?: number): ECSStateReply {
649
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
650
- let end = length === undefined ? reader.len : reader.pos + length;
651
- const message = createBaseECSStateReply();
652
- while (reader.pos < end) {
653
- const tag = reader.uint32();
654
- switch (tag >>> 3) {
655
- case 1:
656
- if (tag != 10) {
657
- break;
658
- }
659
-
660
- message.state.push(ECSState.decode(reader, reader.uint32()));
661
- continue;
662
- case 2:
663
- if (tag != 18) {
664
- break;
665
- }
666
-
667
- message.stateComponents.push(reader.string());
668
- continue;
669
- case 3:
670
- if (tag != 26) {
671
- break;
672
- }
673
-
674
- message.stateEntities.push(reader.string());
675
- continue;
676
- case 4:
677
- if (tag != 34) {
678
- break;
679
- }
680
-
681
- message.stateHash = reader.string();
682
- continue;
683
- case 5:
684
- if (tag != 40) {
685
- break;
686
- }
687
-
688
- message.blockNumber = reader.uint32();
689
- continue;
690
- }
691
- if ((tag & 7) == 4 || tag == 0) {
692
- break;
693
- }
694
- reader.skipType(tag & 7);
695
- }
696
- return message;
697
- },
698
-
699
- create(base?: DeepPartial<ECSStateReply>): ECSStateReply {
700
- return ECSStateReply.fromPartial(base ?? {});
701
- },
702
-
703
- fromPartial(object: DeepPartial<ECSStateReply>): ECSStateReply {
704
- const message = createBaseECSStateReply();
705
- message.state = object.state?.map((e) => ECSState.fromPartial(e)) || [];
706
- message.stateComponents = object.stateComponents?.map((e) => e) || [];
707
- message.stateEntities = object.stateEntities?.map((e) => e) || [];
708
- message.stateHash = object.stateHash ?? "";
709
- message.blockNumber = object.blockNumber ?? 0;
710
- return message;
711
- },
712
- };
713
-
714
- function createBaseECSStateReplyV2(): ECSStateReplyV2 {
715
- return { state: [], stateComponents: [], stateEntities: [], stateHash: "", blockNumber: 0 };
716
- }
717
-
718
- export const ECSStateReplyV2 = {
719
- encode(message: ECSStateReplyV2, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
720
- for (const v of message.state) {
721
- ECSState.encode(v!, writer.uint32(10).fork()).ldelim();
722
- }
723
- for (const v of message.stateComponents) {
724
- writer.uint32(18).string(v!);
725
- }
726
- for (const v of message.stateEntities) {
727
- writer.uint32(26).bytes(v!);
728
- }
729
- if (message.stateHash !== "") {
730
- writer.uint32(34).string(message.stateHash);
731
- }
732
- if (message.blockNumber !== 0) {
733
- writer.uint32(40).uint32(message.blockNumber);
734
- }
735
- return writer;
736
- },
737
-
738
- decode(input: _m0.Reader | Uint8Array, length?: number): ECSStateReplyV2 {
739
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
740
- let end = length === undefined ? reader.len : reader.pos + length;
741
- const message = createBaseECSStateReplyV2();
742
- while (reader.pos < end) {
743
- const tag = reader.uint32();
744
- switch (tag >>> 3) {
745
- case 1:
746
- if (tag != 10) {
747
- break;
748
- }
749
-
750
- message.state.push(ECSState.decode(reader, reader.uint32()));
751
- continue;
752
- case 2:
753
- if (tag != 18) {
754
- break;
755
- }
756
-
757
- message.stateComponents.push(reader.string());
758
- continue;
759
- case 3:
760
- if (tag != 26) {
761
- break;
762
- }
763
-
764
- message.stateEntities.push(reader.bytes());
765
- continue;
766
- case 4:
767
- if (tag != 34) {
768
- break;
769
- }
770
-
771
- message.stateHash = reader.string();
772
- continue;
773
- case 5:
774
- if (tag != 40) {
775
- break;
776
- }
777
-
778
- message.blockNumber = reader.uint32();
779
- continue;
780
- }
781
- if ((tag & 7) == 4 || tag == 0) {
782
- break;
783
- }
784
- reader.skipType(tag & 7);
785
- }
786
- return message;
787
- },
788
-
789
- create(base?: DeepPartial<ECSStateReplyV2>): ECSStateReplyV2 {
790
- return ECSStateReplyV2.fromPartial(base ?? {});
791
- },
792
-
793
- fromPartial(object: DeepPartial<ECSStateReplyV2>): ECSStateReplyV2 {
794
- const message = createBaseECSStateReplyV2();
795
- message.state = object.state?.map((e) => ECSState.fromPartial(e)) || [];
796
- message.stateComponents = object.stateComponents?.map((e) => e) || [];
797
- message.stateEntities = object.stateEntities?.map((e) => e) || [];
798
- message.stateHash = object.stateHash ?? "";
799
- message.blockNumber = object.blockNumber ?? 0;
800
- return message;
801
- },
802
- };
803
-
804
- function createBaseECSStateBlockReply(): ECSStateBlockReply {
805
- return { blockNumber: 0 };
806
- }
807
-
808
- export const ECSStateBlockReply = {
809
- encode(message: ECSStateBlockReply, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
810
- if (message.blockNumber !== 0) {
811
- writer.uint32(8).uint32(message.blockNumber);
812
- }
813
- return writer;
814
- },
815
-
816
- decode(input: _m0.Reader | Uint8Array, length?: number): ECSStateBlockReply {
817
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
818
- let end = length === undefined ? reader.len : reader.pos + length;
819
- const message = createBaseECSStateBlockReply();
820
- while (reader.pos < end) {
821
- const tag = reader.uint32();
822
- switch (tag >>> 3) {
823
- case 1:
824
- if (tag != 8) {
825
- break;
826
- }
827
-
828
- message.blockNumber = reader.uint32();
829
- continue;
830
- }
831
- if ((tag & 7) == 4 || tag == 0) {
832
- break;
833
- }
834
- reader.skipType(tag & 7);
835
- }
836
- return message;
837
- },
838
-
839
- create(base?: DeepPartial<ECSStateBlockReply>): ECSStateBlockReply {
840
- return ECSStateBlockReply.fromPartial(base ?? {});
841
- },
842
-
843
- fromPartial(object: DeepPartial<ECSStateBlockReply>): ECSStateBlockReply {
844
- const message = createBaseECSStateBlockReply();
845
- message.blockNumber = object.blockNumber ?? 0;
846
- return message;
847
- },
848
- };
849
-
850
- /** The Snapshot Service definition. */
851
- export type ECSStateSnapshotServiceDefinition = typeof ECSStateSnapshotServiceDefinition;
852
- export const ECSStateSnapshotServiceDefinition = {
853
- name: "ECSStateSnapshotService",
854
- fullName: "ecssnapshot.ECSStateSnapshotService",
855
- methods: {
856
- /** Requests the latest ECS state. */
857
- getStateLatest: {
858
- name: "GetStateLatest",
859
- requestType: ECSStateRequestLatest,
860
- requestStream: false,
861
- responseType: ECSStateReply,
862
- responseStream: false,
863
- options: {},
864
- },
865
- /** Requests the latest ECS state in stream format, which will chunk the state. */
866
- getStateLatestStream: {
867
- name: "GetStateLatestStream",
868
- requestType: ECSStateRequestLatestStream,
869
- requestStream: false,
870
- responseType: ECSStateReply,
871
- responseStream: true,
872
- options: {},
873
- },
874
- /**
875
- * Requests the latest ECS state in stream format, which will chunk the state.
876
- *
877
- * V2 version optimized to return entities as raw bytes.
878
- */
879
- getStateLatestStreamV2: {
880
- name: "GetStateLatestStreamV2",
881
- requestType: ECSStateRequestLatestStream,
882
- requestStream: false,
883
- responseType: ECSStateReplyV2,
884
- responseStream: true,
885
- options: {},
886
- },
887
- /** Requests the latest ECS state, with aditional pruning. */
888
- getStateLatestStreamPruned: {
889
- name: "GetStateLatestStreamPruned",
890
- requestType: ECSStateRequestLatestStreamPruned,
891
- requestStream: false,
892
- responseType: ECSStateReply,
893
- responseStream: true,
894
- options: {},
895
- },
896
- /**
897
- * Requests the latest ECS state, with aditional pruning.
898
- *
899
- * V2 version optimized to return entities as raw bytes.
900
- */
901
- getStateLatestStreamPrunedV2: {
902
- name: "GetStateLatestStreamPrunedV2",
903
- requestType: ECSStateRequestLatestStreamPruned,
904
- requestStream: false,
905
- responseType: ECSStateReplyV2,
906
- responseStream: true,
907
- options: {},
908
- },
909
- /** Requests the latest block number based on the latest ECS state. */
910
- getStateBlockLatest: {
911
- name: "GetStateBlockLatest",
912
- requestType: ECSStateBlockRequestLatest,
913
- requestStream: false,
914
- responseType: ECSStateBlockReply,
915
- responseStream: false,
916
- options: {},
917
- },
918
- /** Requests the ECS state at specific block. */
919
- getStateAtBlock: {
920
- name: "GetStateAtBlock",
921
- requestType: ECSStateRequestAtBlock,
922
- requestStream: false,
923
- responseType: ECSStateReply,
924
- responseStream: false,
925
- options: {},
926
- },
927
- /** Requests a list of known worlds based on chain state. */
928
- getWorlds: {
929
- name: "GetWorlds",
930
- requestType: WorldsRequest,
931
- requestStream: false,
932
- responseType: Worlds,
933
- responseStream: false,
934
- options: {},
935
- },
936
- },
937
- } as const;
938
-
939
- export interface ECSStateSnapshotServiceImplementation<CallContextExt = {}> {
940
- /** Requests the latest ECS state. */
941
- getStateLatest(
942
- request: ECSStateRequestLatest,
943
- context: CallContext & CallContextExt
944
- ): Promise<DeepPartial<ECSStateReply>>;
945
- /** Requests the latest ECS state in stream format, which will chunk the state. */
946
- getStateLatestStream(
947
- request: ECSStateRequestLatestStream,
948
- context: CallContext & CallContextExt
949
- ): ServerStreamingMethodResult<DeepPartial<ECSStateReply>>;
950
- /**
951
- * Requests the latest ECS state in stream format, which will chunk the state.
952
- *
953
- * V2 version optimized to return entities as raw bytes.
954
- */
955
- getStateLatestStreamV2(
956
- request: ECSStateRequestLatestStream,
957
- context: CallContext & CallContextExt
958
- ): ServerStreamingMethodResult<DeepPartial<ECSStateReplyV2>>;
959
- /** Requests the latest ECS state, with aditional pruning. */
960
- getStateLatestStreamPruned(
961
- request: ECSStateRequestLatestStreamPruned,
962
- context: CallContext & CallContextExt
963
- ): ServerStreamingMethodResult<DeepPartial<ECSStateReply>>;
964
- /**
965
- * Requests the latest ECS state, with aditional pruning.
966
- *
967
- * V2 version optimized to return entities as raw bytes.
968
- */
969
- getStateLatestStreamPrunedV2(
970
- request: ECSStateRequestLatestStreamPruned,
971
- context: CallContext & CallContextExt
972
- ): ServerStreamingMethodResult<DeepPartial<ECSStateReplyV2>>;
973
- /** Requests the latest block number based on the latest ECS state. */
974
- getStateBlockLatest(
975
- request: ECSStateBlockRequestLatest,
976
- context: CallContext & CallContextExt
977
- ): Promise<DeepPartial<ECSStateBlockReply>>;
978
- /** Requests the ECS state at specific block. */
979
- getStateAtBlock(
980
- request: ECSStateRequestAtBlock,
981
- context: CallContext & CallContextExt
982
- ): Promise<DeepPartial<ECSStateReply>>;
983
- /** Requests a list of known worlds based on chain state. */
984
- getWorlds(request: WorldsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Worlds>>;
985
- }
986
-
987
- export interface ECSStateSnapshotServiceClient<CallOptionsExt = {}> {
988
- /** Requests the latest ECS state. */
989
- getStateLatest(
990
- request: DeepPartial<ECSStateRequestLatest>,
991
- options?: CallOptions & CallOptionsExt
992
- ): Promise<ECSStateReply>;
993
- /** Requests the latest ECS state in stream format, which will chunk the state. */
994
- getStateLatestStream(
995
- request: DeepPartial<ECSStateRequestLatestStream>,
996
- options?: CallOptions & CallOptionsExt
997
- ): AsyncIterable<ECSStateReply>;
998
- /**
999
- * Requests the latest ECS state in stream format, which will chunk the state.
1000
- *
1001
- * V2 version optimized to return entities as raw bytes.
1002
- */
1003
- getStateLatestStreamV2(
1004
- request: DeepPartial<ECSStateRequestLatestStream>,
1005
- options?: CallOptions & CallOptionsExt
1006
- ): AsyncIterable<ECSStateReplyV2>;
1007
- /** Requests the latest ECS state, with aditional pruning. */
1008
- getStateLatestStreamPruned(
1009
- request: DeepPartial<ECSStateRequestLatestStreamPruned>,
1010
- options?: CallOptions & CallOptionsExt
1011
- ): AsyncIterable<ECSStateReply>;
1012
- /**
1013
- * Requests the latest ECS state, with aditional pruning.
1014
- *
1015
- * V2 version optimized to return entities as raw bytes.
1016
- */
1017
- getStateLatestStreamPrunedV2(
1018
- request: DeepPartial<ECSStateRequestLatestStreamPruned>,
1019
- options?: CallOptions & CallOptionsExt
1020
- ): AsyncIterable<ECSStateReplyV2>;
1021
- /** Requests the latest block number based on the latest ECS state. */
1022
- getStateBlockLatest(
1023
- request: DeepPartial<ECSStateBlockRequestLatest>,
1024
- options?: CallOptions & CallOptionsExt
1025
- ): Promise<ECSStateBlockReply>;
1026
- /** Requests the ECS state at specific block. */
1027
- getStateAtBlock(
1028
- request: DeepPartial<ECSStateRequestAtBlock>,
1029
- options?: CallOptions & CallOptionsExt
1030
- ): Promise<ECSStateReply>;
1031
- /** Requests a list of known worlds based on chain state. */
1032
- getWorlds(request: DeepPartial<WorldsRequest>, options?: CallOptions & CallOptionsExt): Promise<Worlds>;
1033
- }
1034
-
1035
- declare var self: any | undefined;
1036
- declare var window: any | undefined;
1037
- declare var global: any | undefined;
1038
- var tsProtoGlobalThis: any = (() => {
1039
- if (typeof globalThis !== "undefined") {
1040
- return globalThis;
1041
- }
1042
- if (typeof self !== "undefined") {
1043
- return self;
1044
- }
1045
- if (typeof window !== "undefined") {
1046
- return window;
1047
- }
1048
- if (typeof global !== "undefined") {
1049
- return global;
1050
- }
1051
- throw "Unable to locate global object";
1052
- })();
1053
-
1054
- type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
1055
-
1056
- export type DeepPartial<T> = T extends Builtin
1057
- ? T
1058
- : T extends Array<infer U>
1059
- ? Array<DeepPartial<U>>
1060
- : T extends ReadonlyArray<infer U>
1061
- ? ReadonlyArray<DeepPartial<U>>
1062
- : T extends {}
1063
- ? { [K in keyof T]?: DeepPartial<T[K]> }
1064
- : Partial<T>;
1065
-
1066
- function longToNumber(long: Long): number {
1067
- if (long.gt(Number.MAX_SAFE_INTEGER)) {
1068
- throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
1069
- }
1070
- return long.toNumber();
1071
- }
1072
-
1073
- if (_m0.util.Long !== Long) {
1074
- _m0.util.Long = Long as any;
1075
- _m0.configure();
1076
- }
1077
-
1078
- export type ServerStreamingMethodResult<Response> = { [Symbol.asyncIterator](): AsyncIterator<Response, void> };