@sentio/runtime 1.0.0-rc.5 → 1.36.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,3988 +0,0 @@
1
- "use strict";
2
- var __importDefault = (this && this.__importDefault) || function (mod) {
3
- return (mod && mod.__esModule) ? mod : { "default": mod };
4
- };
5
- Object.defineProperty(exports, "__esModule", { value: true });
6
- exports.Data_EthLog = exports.Data = exports.RawTransaction = exports.ProcessBindingResponse = exports.ProcessBindingsRequest = exports.Topic = exports.AptosCallFilter = exports.AptosCallHandlerConfig = exports.AptosEventFilter = exports.AptosEventHandlerConfig = exports.InstructionHandlerConfig = exports.LogFilter = exports.LogHandlerConfig = exports.TraceHandlerConfig = exports.BlockHandlerConfig = exports.StartRequest = exports.TemplateInstance = exports.ContractInfo = exports.AptosOnIntervalConfig = exports.OnIntervalConfig = exports.HandleInterval = exports.AccountConfig = exports.AggregationConfig = exports.MetricConfig = exports.ExportConfig = exports.EventTrackingConfig = exports.RetentionConfig = exports.TotalPerEntityAggregation = exports.ContractConfig = exports.ProcessConfigResponse = exports.ProcessConfigRequest = exports.ProjectConfig = exports.totalPerEntityAggregation_TypeToJSON = exports.totalPerEntityAggregation_TypeFromJSON = exports.TotalPerEntityAggregation_Type = exports.logLevelToJSON = exports.logLevelFromJSON = exports.LogLevel = exports.handlerTypeToJSON = exports.handlerTypeFromJSON = exports.HandlerType = exports.addressTypeToJSON = exports.addressTypeFromJSON = exports.AddressType = exports.aggregationTypeToJSON = exports.aggregationTypeFromJSON = exports.AggregationType = exports.metricTypeToJSON = exports.metricTypeFromJSON = exports.MetricType = void 0;
7
- exports.ProcessorDefinition = exports.ExportResult = exports.EventTrackingResult = exports.LogResult = exports.CounterResult = exports.GaugeResult = exports.RuntimeInfo = exports.BigInteger = exports.MetricValue = exports.RecordMetaData_LabelsEntry = exports.RecordMetaData = exports.ProcessResult = exports.DataBinding = exports.Data_AptResource = exports.Data_AptCall = exports.Data_AptEvent = exports.Data_SolInstruction = exports.Data_EthTrace = exports.Data_EthTransaction = exports.Data_EthBlock = void 0;
8
- /* eslint-disable */
9
- const long_1 = __importDefault(require("long"));
10
- const minimal_1 = __importDefault(require("protobufjs/minimal"));
11
- const empty_1 = require("../../google/protobuf/empty");
12
- const struct_1 = require("../../google/protobuf/struct");
13
- var MetricType;
14
- (function (MetricType) {
15
- MetricType[MetricType["UNKNOWN_TYPE"] = 0] = "UNKNOWN_TYPE";
16
- MetricType[MetricType["COUNTER"] = 1] = "COUNTER";
17
- MetricType[MetricType["GAUGE"] = 2] = "GAUGE";
18
- MetricType[MetricType["HISTOGRAM"] = 3] = "HISTOGRAM";
19
- MetricType[MetricType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
20
- })(MetricType = exports.MetricType || (exports.MetricType = {}));
21
- function metricTypeFromJSON(object) {
22
- switch (object) {
23
- case 0:
24
- case "UNKNOWN_TYPE":
25
- return MetricType.UNKNOWN_TYPE;
26
- case 1:
27
- case "COUNTER":
28
- return MetricType.COUNTER;
29
- case 2:
30
- case "GAUGE":
31
- return MetricType.GAUGE;
32
- case 3:
33
- case "HISTOGRAM":
34
- return MetricType.HISTOGRAM;
35
- case -1:
36
- case "UNRECOGNIZED":
37
- default:
38
- return MetricType.UNRECOGNIZED;
39
- }
40
- }
41
- exports.metricTypeFromJSON = metricTypeFromJSON;
42
- function metricTypeToJSON(object) {
43
- switch (object) {
44
- case MetricType.UNKNOWN_TYPE:
45
- return "UNKNOWN_TYPE";
46
- case MetricType.COUNTER:
47
- return "COUNTER";
48
- case MetricType.GAUGE:
49
- return "GAUGE";
50
- case MetricType.HISTOGRAM:
51
- return "HISTOGRAM";
52
- case MetricType.UNRECOGNIZED:
53
- default:
54
- return "UNRECOGNIZED";
55
- }
56
- }
57
- exports.metricTypeToJSON = metricTypeToJSON;
58
- var AggregationType;
59
- (function (AggregationType) {
60
- AggregationType[AggregationType["COUNT"] = 0] = "COUNT";
61
- AggregationType[AggregationType["SUM"] = 1] = "SUM";
62
- AggregationType[AggregationType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
63
- })(AggregationType = exports.AggregationType || (exports.AggregationType = {}));
64
- function aggregationTypeFromJSON(object) {
65
- switch (object) {
66
- case 0:
67
- case "COUNT":
68
- return AggregationType.COUNT;
69
- case 1:
70
- case "SUM":
71
- return AggregationType.SUM;
72
- case -1:
73
- case "UNRECOGNIZED":
74
- default:
75
- return AggregationType.UNRECOGNIZED;
76
- }
77
- }
78
- exports.aggregationTypeFromJSON = aggregationTypeFromJSON;
79
- function aggregationTypeToJSON(object) {
80
- switch (object) {
81
- case AggregationType.COUNT:
82
- return "COUNT";
83
- case AggregationType.SUM:
84
- return "SUM";
85
- case AggregationType.UNRECOGNIZED:
86
- default:
87
- return "UNRECOGNIZED";
88
- }
89
- }
90
- exports.aggregationTypeToJSON = aggregationTypeToJSON;
91
- var AddressType;
92
- (function (AddressType) {
93
- AddressType[AddressType["ERC20"] = 0] = "ERC20";
94
- AddressType[AddressType["ERC721"] = 1] = "ERC721";
95
- AddressType[AddressType["ERC1155"] = 2] = "ERC1155";
96
- AddressType[AddressType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
97
- })(AddressType = exports.AddressType || (exports.AddressType = {}));
98
- function addressTypeFromJSON(object) {
99
- switch (object) {
100
- case 0:
101
- case "ERC20":
102
- return AddressType.ERC20;
103
- case 1:
104
- case "ERC721":
105
- return AddressType.ERC721;
106
- case 2:
107
- case "ERC1155":
108
- return AddressType.ERC1155;
109
- case -1:
110
- case "UNRECOGNIZED":
111
- default:
112
- return AddressType.UNRECOGNIZED;
113
- }
114
- }
115
- exports.addressTypeFromJSON = addressTypeFromJSON;
116
- function addressTypeToJSON(object) {
117
- switch (object) {
118
- case AddressType.ERC20:
119
- return "ERC20";
120
- case AddressType.ERC721:
121
- return "ERC721";
122
- case AddressType.ERC1155:
123
- return "ERC1155";
124
- case AddressType.UNRECOGNIZED:
125
- default:
126
- return "UNRECOGNIZED";
127
- }
128
- }
129
- exports.addressTypeToJSON = addressTypeToJSON;
130
- var HandlerType;
131
- (function (HandlerType) {
132
- HandlerType[HandlerType["UNKNOWN"] = 0] = "UNKNOWN";
133
- HandlerType[HandlerType["ETH_LOG"] = 1] = "ETH_LOG";
134
- HandlerType[HandlerType["ETH_BLOCK"] = 2] = "ETH_BLOCK";
135
- HandlerType[HandlerType["ETH_TRACE"] = 5] = "ETH_TRACE";
136
- HandlerType[HandlerType["SOL_INSTRUCTION"] = 4] = "SOL_INSTRUCTION";
137
- HandlerType[HandlerType["APT_EVENT"] = 6] = "APT_EVENT";
138
- HandlerType[HandlerType["APT_CALL"] = 7] = "APT_CALL";
139
- HandlerType[HandlerType["APT_RESOURCE"] = 8] = "APT_RESOURCE";
140
- HandlerType[HandlerType["SUI_TRANSACTION"] = 3] = "SUI_TRANSACTION";
141
- HandlerType[HandlerType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
142
- })(HandlerType = exports.HandlerType || (exports.HandlerType = {}));
143
- function handlerTypeFromJSON(object) {
144
- switch (object) {
145
- case 0:
146
- case "UNKNOWN":
147
- return HandlerType.UNKNOWN;
148
- case 1:
149
- case "ETH_LOG":
150
- return HandlerType.ETH_LOG;
151
- case 2:
152
- case "ETH_BLOCK":
153
- return HandlerType.ETH_BLOCK;
154
- case 5:
155
- case "ETH_TRACE":
156
- return HandlerType.ETH_TRACE;
157
- case 4:
158
- case "SOL_INSTRUCTION":
159
- return HandlerType.SOL_INSTRUCTION;
160
- case 6:
161
- case "APT_EVENT":
162
- return HandlerType.APT_EVENT;
163
- case 7:
164
- case "APT_CALL":
165
- return HandlerType.APT_CALL;
166
- case 8:
167
- case "APT_RESOURCE":
168
- return HandlerType.APT_RESOURCE;
169
- case 3:
170
- case "SUI_TRANSACTION":
171
- return HandlerType.SUI_TRANSACTION;
172
- case -1:
173
- case "UNRECOGNIZED":
174
- default:
175
- return HandlerType.UNRECOGNIZED;
176
- }
177
- }
178
- exports.handlerTypeFromJSON = handlerTypeFromJSON;
179
- function handlerTypeToJSON(object) {
180
- switch (object) {
181
- case HandlerType.UNKNOWN:
182
- return "UNKNOWN";
183
- case HandlerType.ETH_LOG:
184
- return "ETH_LOG";
185
- case HandlerType.ETH_BLOCK:
186
- return "ETH_BLOCK";
187
- case HandlerType.ETH_TRACE:
188
- return "ETH_TRACE";
189
- case HandlerType.SOL_INSTRUCTION:
190
- return "SOL_INSTRUCTION";
191
- case HandlerType.APT_EVENT:
192
- return "APT_EVENT";
193
- case HandlerType.APT_CALL:
194
- return "APT_CALL";
195
- case HandlerType.APT_RESOURCE:
196
- return "APT_RESOURCE";
197
- case HandlerType.SUI_TRANSACTION:
198
- return "SUI_TRANSACTION";
199
- case HandlerType.UNRECOGNIZED:
200
- default:
201
- return "UNRECOGNIZED";
202
- }
203
- }
204
- exports.handlerTypeToJSON = handlerTypeToJSON;
205
- var LogLevel;
206
- (function (LogLevel) {
207
- LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
208
- LogLevel[LogLevel["INFO"] = 1] = "INFO";
209
- LogLevel[LogLevel["WARNING"] = 2] = "WARNING";
210
- LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
211
- LogLevel[LogLevel["CRITICAL"] = 4] = "CRITICAL";
212
- LogLevel[LogLevel["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
213
- })(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
214
- function logLevelFromJSON(object) {
215
- switch (object) {
216
- case 0:
217
- case "DEBUG":
218
- return LogLevel.DEBUG;
219
- case 1:
220
- case "INFO":
221
- return LogLevel.INFO;
222
- case 2:
223
- case "WARNING":
224
- return LogLevel.WARNING;
225
- case 3:
226
- case "ERROR":
227
- return LogLevel.ERROR;
228
- case 4:
229
- case "CRITICAL":
230
- return LogLevel.CRITICAL;
231
- case -1:
232
- case "UNRECOGNIZED":
233
- default:
234
- return LogLevel.UNRECOGNIZED;
235
- }
236
- }
237
- exports.logLevelFromJSON = logLevelFromJSON;
238
- function logLevelToJSON(object) {
239
- switch (object) {
240
- case LogLevel.DEBUG:
241
- return "DEBUG";
242
- case LogLevel.INFO:
243
- return "INFO";
244
- case LogLevel.WARNING:
245
- return "WARNING";
246
- case LogLevel.ERROR:
247
- return "ERROR";
248
- case LogLevel.CRITICAL:
249
- return "CRITICAL";
250
- case LogLevel.UNRECOGNIZED:
251
- default:
252
- return "UNRECOGNIZED";
253
- }
254
- }
255
- exports.logLevelToJSON = logLevelToJSON;
256
- var TotalPerEntityAggregation_Type;
257
- (function (TotalPerEntityAggregation_Type) {
258
- TotalPerEntityAggregation_Type[TotalPerEntityAggregation_Type["AVG"] = 0] = "AVG";
259
- TotalPerEntityAggregation_Type[TotalPerEntityAggregation_Type["MEDIAN"] = 1] = "MEDIAN";
260
- TotalPerEntityAggregation_Type[TotalPerEntityAggregation_Type["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
261
- })(TotalPerEntityAggregation_Type = exports.TotalPerEntityAggregation_Type || (exports.TotalPerEntityAggregation_Type = {}));
262
- function totalPerEntityAggregation_TypeFromJSON(object) {
263
- switch (object) {
264
- case 0:
265
- case "AVG":
266
- return TotalPerEntityAggregation_Type.AVG;
267
- case 1:
268
- case "MEDIAN":
269
- return TotalPerEntityAggregation_Type.MEDIAN;
270
- case -1:
271
- case "UNRECOGNIZED":
272
- default:
273
- return TotalPerEntityAggregation_Type.UNRECOGNIZED;
274
- }
275
- }
276
- exports.totalPerEntityAggregation_TypeFromJSON = totalPerEntityAggregation_TypeFromJSON;
277
- function totalPerEntityAggregation_TypeToJSON(object) {
278
- switch (object) {
279
- case TotalPerEntityAggregation_Type.AVG:
280
- return "AVG";
281
- case TotalPerEntityAggregation_Type.MEDIAN:
282
- return "MEDIAN";
283
- case TotalPerEntityAggregation_Type.UNRECOGNIZED:
284
- default:
285
- return "UNRECOGNIZED";
286
- }
287
- }
288
- exports.totalPerEntityAggregation_TypeToJSON = totalPerEntityAggregation_TypeToJSON;
289
- function createBaseProjectConfig() {
290
- return { name: "", version: "" };
291
- }
292
- exports.ProjectConfig = {
293
- encode(message, writer = minimal_1.default.Writer.create()) {
294
- if (message.name !== "") {
295
- writer.uint32(10).string(message.name);
296
- }
297
- if (message.version !== "") {
298
- writer.uint32(26).string(message.version);
299
- }
300
- return writer;
301
- },
302
- decode(input, length) {
303
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
304
- let end = length === undefined ? reader.len : reader.pos + length;
305
- const message = createBaseProjectConfig();
306
- while (reader.pos < end) {
307
- const tag = reader.uint32();
308
- switch (tag >>> 3) {
309
- case 1:
310
- message.name = reader.string();
311
- break;
312
- case 3:
313
- message.version = reader.string();
314
- break;
315
- default:
316
- reader.skipType(tag & 7);
317
- break;
318
- }
319
- }
320
- return message;
321
- },
322
- fromJSON(object) {
323
- return {
324
- name: isSet(object.name) ? String(object.name) : "",
325
- version: isSet(object.version) ? String(object.version) : "",
326
- };
327
- },
328
- toJSON(message) {
329
- const obj = {};
330
- message.name !== undefined && (obj.name = message.name);
331
- message.version !== undefined && (obj.version = message.version);
332
- return obj;
333
- },
334
- fromPartial(object) {
335
- const message = createBaseProjectConfig();
336
- message.name = object.name ?? "";
337
- message.version = object.version ?? "";
338
- return message;
339
- },
340
- };
341
- function createBaseProcessConfigRequest() {
342
- return {};
343
- }
344
- exports.ProcessConfigRequest = {
345
- encode(_, writer = minimal_1.default.Writer.create()) {
346
- return writer;
347
- },
348
- decode(input, length) {
349
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
350
- let end = length === undefined ? reader.len : reader.pos + length;
351
- const message = createBaseProcessConfigRequest();
352
- while (reader.pos < end) {
353
- const tag = reader.uint32();
354
- switch (tag >>> 3) {
355
- default:
356
- reader.skipType(tag & 7);
357
- break;
358
- }
359
- }
360
- return message;
361
- },
362
- fromJSON(_) {
363
- return {};
364
- },
365
- toJSON(_) {
366
- const obj = {};
367
- return obj;
368
- },
369
- fromPartial(_) {
370
- const message = createBaseProcessConfigRequest();
371
- return message;
372
- },
373
- };
374
- function createBaseProcessConfigResponse() {
375
- return {
376
- config: undefined,
377
- contractConfigs: [],
378
- templateInstances: [],
379
- accountConfigs: [],
380
- metricConfigs: [],
381
- eventTrackingConfigs: [],
382
- exportConfigs: [],
383
- };
384
- }
385
- exports.ProcessConfigResponse = {
386
- encode(message, writer = minimal_1.default.Writer.create()) {
387
- if (message.config !== undefined) {
388
- exports.ProjectConfig.encode(message.config, writer.uint32(10).fork()).ldelim();
389
- }
390
- for (const v of message.contractConfigs) {
391
- exports.ContractConfig.encode(v, writer.uint32(18).fork()).ldelim();
392
- }
393
- for (const v of message.templateInstances) {
394
- exports.TemplateInstance.encode(v, writer.uint32(26).fork()).ldelim();
395
- }
396
- for (const v of message.accountConfigs) {
397
- exports.AccountConfig.encode(v, writer.uint32(34).fork()).ldelim();
398
- }
399
- for (const v of message.metricConfigs) {
400
- exports.MetricConfig.encode(v, writer.uint32(42).fork()).ldelim();
401
- }
402
- for (const v of message.eventTrackingConfigs) {
403
- exports.EventTrackingConfig.encode(v, writer.uint32(50).fork()).ldelim();
404
- }
405
- for (const v of message.exportConfigs) {
406
- exports.ExportConfig.encode(v, writer.uint32(58).fork()).ldelim();
407
- }
408
- return writer;
409
- },
410
- decode(input, length) {
411
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
412
- let end = length === undefined ? reader.len : reader.pos + length;
413
- const message = createBaseProcessConfigResponse();
414
- while (reader.pos < end) {
415
- const tag = reader.uint32();
416
- switch (tag >>> 3) {
417
- case 1:
418
- message.config = exports.ProjectConfig.decode(reader, reader.uint32());
419
- break;
420
- case 2:
421
- message.contractConfigs.push(exports.ContractConfig.decode(reader, reader.uint32()));
422
- break;
423
- case 3:
424
- message.templateInstances.push(exports.TemplateInstance.decode(reader, reader.uint32()));
425
- break;
426
- case 4:
427
- message.accountConfigs.push(exports.AccountConfig.decode(reader, reader.uint32()));
428
- break;
429
- case 5:
430
- message.metricConfigs.push(exports.MetricConfig.decode(reader, reader.uint32()));
431
- break;
432
- case 6:
433
- message.eventTrackingConfigs.push(exports.EventTrackingConfig.decode(reader, reader.uint32()));
434
- break;
435
- case 7:
436
- message.exportConfigs.push(exports.ExportConfig.decode(reader, reader.uint32()));
437
- break;
438
- default:
439
- reader.skipType(tag & 7);
440
- break;
441
- }
442
- }
443
- return message;
444
- },
445
- fromJSON(object) {
446
- return {
447
- config: isSet(object.config) ? exports.ProjectConfig.fromJSON(object.config) : undefined,
448
- contractConfigs: Array.isArray(object?.contractConfigs)
449
- ? object.contractConfigs.map((e) => exports.ContractConfig.fromJSON(e))
450
- : [],
451
- templateInstances: Array.isArray(object?.templateInstances)
452
- ? object.templateInstances.map((e) => exports.TemplateInstance.fromJSON(e))
453
- : [],
454
- accountConfigs: Array.isArray(object?.accountConfigs)
455
- ? object.accountConfigs.map((e) => exports.AccountConfig.fromJSON(e))
456
- : [],
457
- metricConfigs: Array.isArray(object?.metricConfigs)
458
- ? object.metricConfigs.map((e) => exports.MetricConfig.fromJSON(e))
459
- : [],
460
- eventTrackingConfigs: Array.isArray(object?.eventTrackingConfigs)
461
- ? object.eventTrackingConfigs.map((e) => exports.EventTrackingConfig.fromJSON(e))
462
- : [],
463
- exportConfigs: Array.isArray(object?.exportConfigs)
464
- ? object.exportConfigs.map((e) => exports.ExportConfig.fromJSON(e))
465
- : [],
466
- };
467
- },
468
- toJSON(message) {
469
- const obj = {};
470
- message.config !== undefined && (obj.config = message.config ? exports.ProjectConfig.toJSON(message.config) : undefined);
471
- if (message.contractConfigs) {
472
- obj.contractConfigs = message.contractConfigs.map((e) => e ? exports.ContractConfig.toJSON(e) : undefined);
473
- }
474
- else {
475
- obj.contractConfigs = [];
476
- }
477
- if (message.templateInstances) {
478
- obj.templateInstances = message.templateInstances.map((e) => e ? exports.TemplateInstance.toJSON(e) : undefined);
479
- }
480
- else {
481
- obj.templateInstances = [];
482
- }
483
- if (message.accountConfigs) {
484
- obj.accountConfigs = message.accountConfigs.map((e) => e ? exports.AccountConfig.toJSON(e) : undefined);
485
- }
486
- else {
487
- obj.accountConfigs = [];
488
- }
489
- if (message.metricConfigs) {
490
- obj.metricConfigs = message.metricConfigs.map((e) => e ? exports.MetricConfig.toJSON(e) : undefined);
491
- }
492
- else {
493
- obj.metricConfigs = [];
494
- }
495
- if (message.eventTrackingConfigs) {
496
- obj.eventTrackingConfigs = message.eventTrackingConfigs.map((e) => e ? exports.EventTrackingConfig.toJSON(e) : undefined);
497
- }
498
- else {
499
- obj.eventTrackingConfigs = [];
500
- }
501
- if (message.exportConfigs) {
502
- obj.exportConfigs = message.exportConfigs.map((e) => e ? exports.ExportConfig.toJSON(e) : undefined);
503
- }
504
- else {
505
- obj.exportConfigs = [];
506
- }
507
- return obj;
508
- },
509
- fromPartial(object) {
510
- const message = createBaseProcessConfigResponse();
511
- message.config = (object.config !== undefined && object.config !== null)
512
- ? exports.ProjectConfig.fromPartial(object.config)
513
- : undefined;
514
- message.contractConfigs = object.contractConfigs?.map((e) => exports.ContractConfig.fromPartial(e)) || [];
515
- message.templateInstances = object.templateInstances?.map((e) => exports.TemplateInstance.fromPartial(e)) || [];
516
- message.accountConfigs = object.accountConfigs?.map((e) => exports.AccountConfig.fromPartial(e)) || [];
517
- message.metricConfigs = object.metricConfigs?.map((e) => exports.MetricConfig.fromPartial(e)) || [];
518
- message.eventTrackingConfigs = object.eventTrackingConfigs?.map((e) => exports.EventTrackingConfig.fromPartial(e)) || [];
519
- message.exportConfigs = object.exportConfigs?.map((e) => exports.ExportConfig.fromPartial(e)) || [];
520
- return message;
521
- },
522
- };
523
- function createBaseContractConfig() {
524
- return {
525
- contract: undefined,
526
- intervalConfigs: [],
527
- logConfigs: [],
528
- traceConfigs: [],
529
- aptosEventConfigs: [],
530
- aptosCallConfigs: [],
531
- instructionConfig: undefined,
532
- startBlock: long_1.default.UZERO,
533
- endBlock: long_1.default.UZERO,
534
- processorType: "",
535
- };
536
- }
537
- exports.ContractConfig = {
538
- encode(message, writer = minimal_1.default.Writer.create()) {
539
- if (message.contract !== undefined) {
540
- exports.ContractInfo.encode(message.contract, writer.uint32(10).fork()).ldelim();
541
- }
542
- for (const v of message.intervalConfigs) {
543
- exports.OnIntervalConfig.encode(v, writer.uint32(90).fork()).ldelim();
544
- }
545
- for (const v of message.logConfigs) {
546
- exports.LogHandlerConfig.encode(v, writer.uint32(26).fork()).ldelim();
547
- }
548
- for (const v of message.traceConfigs) {
549
- exports.TraceHandlerConfig.encode(v, writer.uint32(18).fork()).ldelim();
550
- }
551
- for (const v of message.aptosEventConfigs) {
552
- exports.AptosEventHandlerConfig.encode(v, writer.uint32(74).fork()).ldelim();
553
- }
554
- for (const v of message.aptosCallConfigs) {
555
- exports.AptosCallHandlerConfig.encode(v, writer.uint32(82).fork()).ldelim();
556
- }
557
- if (message.instructionConfig !== undefined) {
558
- exports.InstructionHandlerConfig.encode(message.instructionConfig, writer.uint32(50).fork()).ldelim();
559
- }
560
- if (!message.startBlock.isZero()) {
561
- writer.uint32(32).uint64(message.startBlock);
562
- }
563
- if (!message.endBlock.isZero()) {
564
- writer.uint32(40).uint64(message.endBlock);
565
- }
566
- if (message.processorType !== "") {
567
- writer.uint32(66).string(message.processorType);
568
- }
569
- return writer;
570
- },
571
- decode(input, length) {
572
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
573
- let end = length === undefined ? reader.len : reader.pos + length;
574
- const message = createBaseContractConfig();
575
- while (reader.pos < end) {
576
- const tag = reader.uint32();
577
- switch (tag >>> 3) {
578
- case 1:
579
- message.contract = exports.ContractInfo.decode(reader, reader.uint32());
580
- break;
581
- case 11:
582
- message.intervalConfigs.push(exports.OnIntervalConfig.decode(reader, reader.uint32()));
583
- break;
584
- case 3:
585
- message.logConfigs.push(exports.LogHandlerConfig.decode(reader, reader.uint32()));
586
- break;
587
- case 2:
588
- message.traceConfigs.push(exports.TraceHandlerConfig.decode(reader, reader.uint32()));
589
- break;
590
- case 9:
591
- message.aptosEventConfigs.push(exports.AptosEventHandlerConfig.decode(reader, reader.uint32()));
592
- break;
593
- case 10:
594
- message.aptosCallConfigs.push(exports.AptosCallHandlerConfig.decode(reader, reader.uint32()));
595
- break;
596
- case 6:
597
- message.instructionConfig = exports.InstructionHandlerConfig.decode(reader, reader.uint32());
598
- break;
599
- case 4:
600
- message.startBlock = reader.uint64();
601
- break;
602
- case 5:
603
- message.endBlock = reader.uint64();
604
- break;
605
- case 8:
606
- message.processorType = reader.string();
607
- break;
608
- default:
609
- reader.skipType(tag & 7);
610
- break;
611
- }
612
- }
613
- return message;
614
- },
615
- fromJSON(object) {
616
- return {
617
- contract: isSet(object.contract) ? exports.ContractInfo.fromJSON(object.contract) : undefined,
618
- intervalConfigs: Array.isArray(object?.intervalConfigs)
619
- ? object.intervalConfigs.map((e) => exports.OnIntervalConfig.fromJSON(e))
620
- : [],
621
- logConfigs: Array.isArray(object?.logConfigs)
622
- ? object.logConfigs.map((e) => exports.LogHandlerConfig.fromJSON(e))
623
- : [],
624
- traceConfigs: Array.isArray(object?.traceConfigs)
625
- ? object.traceConfigs.map((e) => exports.TraceHandlerConfig.fromJSON(e))
626
- : [],
627
- aptosEventConfigs: Array.isArray(object?.aptosEventConfigs)
628
- ? object.aptosEventConfigs.map((e) => exports.AptosEventHandlerConfig.fromJSON(e))
629
- : [],
630
- aptosCallConfigs: Array.isArray(object?.aptosCallConfigs)
631
- ? object.aptosCallConfigs.map((e) => exports.AptosCallHandlerConfig.fromJSON(e))
632
- : [],
633
- instructionConfig: isSet(object.instructionConfig)
634
- ? exports.InstructionHandlerConfig.fromJSON(object.instructionConfig)
635
- : undefined,
636
- startBlock: isSet(object.startBlock) ? long_1.default.fromValue(object.startBlock) : long_1.default.UZERO,
637
- endBlock: isSet(object.endBlock) ? long_1.default.fromValue(object.endBlock) : long_1.default.UZERO,
638
- processorType: isSet(object.processorType) ? String(object.processorType) : "",
639
- };
640
- },
641
- toJSON(message) {
642
- const obj = {};
643
- message.contract !== undefined &&
644
- (obj.contract = message.contract ? exports.ContractInfo.toJSON(message.contract) : undefined);
645
- if (message.intervalConfigs) {
646
- obj.intervalConfigs = message.intervalConfigs.map((e) => e ? exports.OnIntervalConfig.toJSON(e) : undefined);
647
- }
648
- else {
649
- obj.intervalConfigs = [];
650
- }
651
- if (message.logConfigs) {
652
- obj.logConfigs = message.logConfigs.map((e) => e ? exports.LogHandlerConfig.toJSON(e) : undefined);
653
- }
654
- else {
655
- obj.logConfigs = [];
656
- }
657
- if (message.traceConfigs) {
658
- obj.traceConfigs = message.traceConfigs.map((e) => e ? exports.TraceHandlerConfig.toJSON(e) : undefined);
659
- }
660
- else {
661
- obj.traceConfigs = [];
662
- }
663
- if (message.aptosEventConfigs) {
664
- obj.aptosEventConfigs = message.aptosEventConfigs.map((e) => e ? exports.AptosEventHandlerConfig.toJSON(e) : undefined);
665
- }
666
- else {
667
- obj.aptosEventConfigs = [];
668
- }
669
- if (message.aptosCallConfigs) {
670
- obj.aptosCallConfigs = message.aptosCallConfigs.map((e) => e ? exports.AptosCallHandlerConfig.toJSON(e) : undefined);
671
- }
672
- else {
673
- obj.aptosCallConfigs = [];
674
- }
675
- message.instructionConfig !== undefined && (obj.instructionConfig = message.instructionConfig
676
- ? exports.InstructionHandlerConfig.toJSON(message.instructionConfig)
677
- : undefined);
678
- message.startBlock !== undefined && (obj.startBlock = (message.startBlock || long_1.default.UZERO).toString());
679
- message.endBlock !== undefined && (obj.endBlock = (message.endBlock || long_1.default.UZERO).toString());
680
- message.processorType !== undefined && (obj.processorType = message.processorType);
681
- return obj;
682
- },
683
- fromPartial(object) {
684
- const message = createBaseContractConfig();
685
- message.contract = (object.contract !== undefined && object.contract !== null)
686
- ? exports.ContractInfo.fromPartial(object.contract)
687
- : undefined;
688
- message.intervalConfigs = object.intervalConfigs?.map((e) => exports.OnIntervalConfig.fromPartial(e)) || [];
689
- message.logConfigs = object.logConfigs?.map((e) => exports.LogHandlerConfig.fromPartial(e)) || [];
690
- message.traceConfigs = object.traceConfigs?.map((e) => exports.TraceHandlerConfig.fromPartial(e)) || [];
691
- message.aptosEventConfigs = object.aptosEventConfigs?.map((e) => exports.AptosEventHandlerConfig.fromPartial(e)) || [];
692
- message.aptosCallConfigs = object.aptosCallConfigs?.map((e) => exports.AptosCallHandlerConfig.fromPartial(e)) || [];
693
- message.instructionConfig = (object.instructionConfig !== undefined && object.instructionConfig !== null)
694
- ? exports.InstructionHandlerConfig.fromPartial(object.instructionConfig)
695
- : undefined;
696
- message.startBlock = (object.startBlock !== undefined && object.startBlock !== null)
697
- ? long_1.default.fromValue(object.startBlock)
698
- : long_1.default.UZERO;
699
- message.endBlock = (object.endBlock !== undefined && object.endBlock !== null)
700
- ? long_1.default.fromValue(object.endBlock)
701
- : long_1.default.UZERO;
702
- message.processorType = object.processorType ?? "";
703
- return message;
704
- },
705
- };
706
- function createBaseTotalPerEntityAggregation() {
707
- return {};
708
- }
709
- exports.TotalPerEntityAggregation = {
710
- encode(_, writer = minimal_1.default.Writer.create()) {
711
- return writer;
712
- },
713
- decode(input, length) {
714
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
715
- let end = length === undefined ? reader.len : reader.pos + length;
716
- const message = createBaseTotalPerEntityAggregation();
717
- while (reader.pos < end) {
718
- const tag = reader.uint32();
719
- switch (tag >>> 3) {
720
- default:
721
- reader.skipType(tag & 7);
722
- break;
723
- }
724
- }
725
- return message;
726
- },
727
- fromJSON(_) {
728
- return {};
729
- },
730
- toJSON(_) {
731
- const obj = {};
732
- return obj;
733
- },
734
- fromPartial(_) {
735
- const message = createBaseTotalPerEntityAggregation();
736
- return message;
737
- },
738
- };
739
- function createBaseRetentionConfig() {
740
- return { retentionEventName: "", days: 0 };
741
- }
742
- exports.RetentionConfig = {
743
- encode(message, writer = minimal_1.default.Writer.create()) {
744
- if (message.retentionEventName !== "") {
745
- writer.uint32(18).string(message.retentionEventName);
746
- }
747
- if (message.days !== 0) {
748
- writer.uint32(24).int32(message.days);
749
- }
750
- return writer;
751
- },
752
- decode(input, length) {
753
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
754
- let end = length === undefined ? reader.len : reader.pos + length;
755
- const message = createBaseRetentionConfig();
756
- while (reader.pos < end) {
757
- const tag = reader.uint32();
758
- switch (tag >>> 3) {
759
- case 2:
760
- message.retentionEventName = reader.string();
761
- break;
762
- case 3:
763
- message.days = reader.int32();
764
- break;
765
- default:
766
- reader.skipType(tag & 7);
767
- break;
768
- }
769
- }
770
- return message;
771
- },
772
- fromJSON(object) {
773
- return {
774
- retentionEventName: isSet(object.retentionEventName) ? String(object.retentionEventName) : "",
775
- days: isSet(object.days) ? Number(object.days) : 0,
776
- };
777
- },
778
- toJSON(message) {
779
- const obj = {};
780
- message.retentionEventName !== undefined && (obj.retentionEventName = message.retentionEventName);
781
- message.days !== undefined && (obj.days = Math.round(message.days));
782
- return obj;
783
- },
784
- fromPartial(object) {
785
- const message = createBaseRetentionConfig();
786
- message.retentionEventName = object.retentionEventName ?? "";
787
- message.days = object.days ?? 0;
788
- return message;
789
- },
790
- };
791
- function createBaseEventTrackingConfig() {
792
- return {
793
- eventName: "",
794
- totalByDay: false,
795
- unique: false,
796
- totalPerEntity: undefined,
797
- distinctAggregationByDays: [],
798
- retentionConfig: undefined,
799
- };
800
- }
801
- exports.EventTrackingConfig = {
802
- encode(message, writer = minimal_1.default.Writer.create()) {
803
- if (message.eventName !== "") {
804
- writer.uint32(10).string(message.eventName);
805
- }
806
- if (message.totalByDay === true) {
807
- writer.uint32(16).bool(message.totalByDay);
808
- }
809
- if (message.unique === true) {
810
- writer.uint32(24).bool(message.unique);
811
- }
812
- if (message.totalPerEntity !== undefined) {
813
- exports.TotalPerEntityAggregation.encode(message.totalPerEntity, writer.uint32(34).fork()).ldelim();
814
- }
815
- writer.uint32(42).fork();
816
- for (const v of message.distinctAggregationByDays) {
817
- writer.int32(v);
818
- }
819
- writer.ldelim();
820
- if (message.retentionConfig !== undefined) {
821
- exports.RetentionConfig.encode(message.retentionConfig, writer.uint32(50).fork()).ldelim();
822
- }
823
- return writer;
824
- },
825
- decode(input, length) {
826
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
827
- let end = length === undefined ? reader.len : reader.pos + length;
828
- const message = createBaseEventTrackingConfig();
829
- while (reader.pos < end) {
830
- const tag = reader.uint32();
831
- switch (tag >>> 3) {
832
- case 1:
833
- message.eventName = reader.string();
834
- break;
835
- case 2:
836
- message.totalByDay = reader.bool();
837
- break;
838
- case 3:
839
- message.unique = reader.bool();
840
- break;
841
- case 4:
842
- message.totalPerEntity = exports.TotalPerEntityAggregation.decode(reader, reader.uint32());
843
- break;
844
- case 5:
845
- if ((tag & 7) === 2) {
846
- const end2 = reader.uint32() + reader.pos;
847
- while (reader.pos < end2) {
848
- message.distinctAggregationByDays.push(reader.int32());
849
- }
850
- }
851
- else {
852
- message.distinctAggregationByDays.push(reader.int32());
853
- }
854
- break;
855
- case 6:
856
- message.retentionConfig = exports.RetentionConfig.decode(reader, reader.uint32());
857
- break;
858
- default:
859
- reader.skipType(tag & 7);
860
- break;
861
- }
862
- }
863
- return message;
864
- },
865
- fromJSON(object) {
866
- return {
867
- eventName: isSet(object.eventName) ? String(object.eventName) : "",
868
- totalByDay: isSet(object.totalByDay) ? Boolean(object.totalByDay) : false,
869
- unique: isSet(object.unique) ? Boolean(object.unique) : false,
870
- totalPerEntity: isSet(object.totalPerEntity)
871
- ? exports.TotalPerEntityAggregation.fromJSON(object.totalPerEntity)
872
- : undefined,
873
- distinctAggregationByDays: Array.isArray(object?.distinctAggregationByDays)
874
- ? object.distinctAggregationByDays.map((e) => Number(e))
875
- : [],
876
- retentionConfig: isSet(object.retentionConfig) ? exports.RetentionConfig.fromJSON(object.retentionConfig) : undefined,
877
- };
878
- },
879
- toJSON(message) {
880
- const obj = {};
881
- message.eventName !== undefined && (obj.eventName = message.eventName);
882
- message.totalByDay !== undefined && (obj.totalByDay = message.totalByDay);
883
- message.unique !== undefined && (obj.unique = message.unique);
884
- message.totalPerEntity !== undefined && (obj.totalPerEntity = message.totalPerEntity
885
- ? exports.TotalPerEntityAggregation.toJSON(message.totalPerEntity)
886
- : undefined);
887
- if (message.distinctAggregationByDays) {
888
- obj.distinctAggregationByDays = message.distinctAggregationByDays.map((e) => Math.round(e));
889
- }
890
- else {
891
- obj.distinctAggregationByDays = [];
892
- }
893
- message.retentionConfig !== undefined &&
894
- (obj.retentionConfig = message.retentionConfig ? exports.RetentionConfig.toJSON(message.retentionConfig) : undefined);
895
- return obj;
896
- },
897
- fromPartial(object) {
898
- const message = createBaseEventTrackingConfig();
899
- message.eventName = object.eventName ?? "";
900
- message.totalByDay = object.totalByDay ?? false;
901
- message.unique = object.unique ?? false;
902
- message.totalPerEntity = (object.totalPerEntity !== undefined && object.totalPerEntity !== null)
903
- ? exports.TotalPerEntityAggregation.fromPartial(object.totalPerEntity)
904
- : undefined;
905
- message.distinctAggregationByDays = object.distinctAggregationByDays?.map((e) => e) || [];
906
- message.retentionConfig = (object.retentionConfig !== undefined && object.retentionConfig !== null)
907
- ? exports.RetentionConfig.fromPartial(object.retentionConfig)
908
- : undefined;
909
- return message;
910
- },
911
- };
912
- function createBaseExportConfig() {
913
- return { name: "", channel: "" };
914
- }
915
- exports.ExportConfig = {
916
- encode(message, writer = minimal_1.default.Writer.create()) {
917
- if (message.name !== "") {
918
- writer.uint32(10).string(message.name);
919
- }
920
- if (message.channel !== "") {
921
- writer.uint32(18).string(message.channel);
922
- }
923
- return writer;
924
- },
925
- decode(input, length) {
926
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
927
- let end = length === undefined ? reader.len : reader.pos + length;
928
- const message = createBaseExportConfig();
929
- while (reader.pos < end) {
930
- const tag = reader.uint32();
931
- switch (tag >>> 3) {
932
- case 1:
933
- message.name = reader.string();
934
- break;
935
- case 2:
936
- message.channel = reader.string();
937
- break;
938
- default:
939
- reader.skipType(tag & 7);
940
- break;
941
- }
942
- }
943
- return message;
944
- },
945
- fromJSON(object) {
946
- return {
947
- name: isSet(object.name) ? String(object.name) : "",
948
- channel: isSet(object.channel) ? String(object.channel) : "",
949
- };
950
- },
951
- toJSON(message) {
952
- const obj = {};
953
- message.name !== undefined && (obj.name = message.name);
954
- message.channel !== undefined && (obj.channel = message.channel);
955
- return obj;
956
- },
957
- fromPartial(object) {
958
- const message = createBaseExportConfig();
959
- message.name = object.name ?? "";
960
- message.channel = object.channel ?? "";
961
- return message;
962
- },
963
- };
964
- function createBaseMetricConfig() {
965
- return { name: "", description: "", unit: "", sparse: false, type: 0, aggregationConfig: undefined };
966
- }
967
- exports.MetricConfig = {
968
- encode(message, writer = minimal_1.default.Writer.create()) {
969
- if (message.name !== "") {
970
- writer.uint32(10).string(message.name);
971
- }
972
- if (message.description !== "") {
973
- writer.uint32(26).string(message.description);
974
- }
975
- if (message.unit !== "") {
976
- writer.uint32(18).string(message.unit);
977
- }
978
- if (message.sparse === true) {
979
- writer.uint32(32).bool(message.sparse);
980
- }
981
- if (message.type !== 0) {
982
- writer.uint32(56).int32(message.type);
983
- }
984
- if (message.aggregationConfig !== undefined) {
985
- exports.AggregationConfig.encode(message.aggregationConfig, writer.uint32(50).fork()).ldelim();
986
- }
987
- return writer;
988
- },
989
- decode(input, length) {
990
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
991
- let end = length === undefined ? reader.len : reader.pos + length;
992
- const message = createBaseMetricConfig();
993
- while (reader.pos < end) {
994
- const tag = reader.uint32();
995
- switch (tag >>> 3) {
996
- case 1:
997
- message.name = reader.string();
998
- break;
999
- case 3:
1000
- message.description = reader.string();
1001
- break;
1002
- case 2:
1003
- message.unit = reader.string();
1004
- break;
1005
- case 4:
1006
- message.sparse = reader.bool();
1007
- break;
1008
- case 7:
1009
- message.type = reader.int32();
1010
- break;
1011
- case 6:
1012
- message.aggregationConfig = exports.AggregationConfig.decode(reader, reader.uint32());
1013
- break;
1014
- default:
1015
- reader.skipType(tag & 7);
1016
- break;
1017
- }
1018
- }
1019
- return message;
1020
- },
1021
- fromJSON(object) {
1022
- return {
1023
- name: isSet(object.name) ? String(object.name) : "",
1024
- description: isSet(object.description) ? String(object.description) : "",
1025
- unit: isSet(object.unit) ? String(object.unit) : "",
1026
- sparse: isSet(object.sparse) ? Boolean(object.sparse) : false,
1027
- type: isSet(object.type) ? metricTypeFromJSON(object.type) : 0,
1028
- aggregationConfig: isSet(object.aggregationConfig)
1029
- ? exports.AggregationConfig.fromJSON(object.aggregationConfig)
1030
- : undefined,
1031
- };
1032
- },
1033
- toJSON(message) {
1034
- const obj = {};
1035
- message.name !== undefined && (obj.name = message.name);
1036
- message.description !== undefined && (obj.description = message.description);
1037
- message.unit !== undefined && (obj.unit = message.unit);
1038
- message.sparse !== undefined && (obj.sparse = message.sparse);
1039
- message.type !== undefined && (obj.type = metricTypeToJSON(message.type));
1040
- message.aggregationConfig !== undefined && (obj.aggregationConfig = message.aggregationConfig
1041
- ? exports.AggregationConfig.toJSON(message.aggregationConfig)
1042
- : undefined);
1043
- return obj;
1044
- },
1045
- fromPartial(object) {
1046
- const message = createBaseMetricConfig();
1047
- message.name = object.name ?? "";
1048
- message.description = object.description ?? "";
1049
- message.unit = object.unit ?? "";
1050
- message.sparse = object.sparse ?? false;
1051
- message.type = object.type ?? 0;
1052
- message.aggregationConfig = (object.aggregationConfig !== undefined && object.aggregationConfig !== null)
1053
- ? exports.AggregationConfig.fromPartial(object.aggregationConfig)
1054
- : undefined;
1055
- return message;
1056
- },
1057
- };
1058
- function createBaseAggregationConfig() {
1059
- return { intervalInMinutes: [], types: [], discardOrigin: false };
1060
- }
1061
- exports.AggregationConfig = {
1062
- encode(message, writer = minimal_1.default.Writer.create()) {
1063
- writer.uint32(10).fork();
1064
- for (const v of message.intervalInMinutes) {
1065
- writer.int32(v);
1066
- }
1067
- writer.ldelim();
1068
- writer.uint32(18).fork();
1069
- for (const v of message.types) {
1070
- writer.int32(v);
1071
- }
1072
- writer.ldelim();
1073
- if (message.discardOrigin === true) {
1074
- writer.uint32(24).bool(message.discardOrigin);
1075
- }
1076
- return writer;
1077
- },
1078
- decode(input, length) {
1079
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1080
- let end = length === undefined ? reader.len : reader.pos + length;
1081
- const message = createBaseAggregationConfig();
1082
- while (reader.pos < end) {
1083
- const tag = reader.uint32();
1084
- switch (tag >>> 3) {
1085
- case 1:
1086
- if ((tag & 7) === 2) {
1087
- const end2 = reader.uint32() + reader.pos;
1088
- while (reader.pos < end2) {
1089
- message.intervalInMinutes.push(reader.int32());
1090
- }
1091
- }
1092
- else {
1093
- message.intervalInMinutes.push(reader.int32());
1094
- }
1095
- break;
1096
- case 2:
1097
- if ((tag & 7) === 2) {
1098
- const end2 = reader.uint32() + reader.pos;
1099
- while (reader.pos < end2) {
1100
- message.types.push(reader.int32());
1101
- }
1102
- }
1103
- else {
1104
- message.types.push(reader.int32());
1105
- }
1106
- break;
1107
- case 3:
1108
- message.discardOrigin = reader.bool();
1109
- break;
1110
- default:
1111
- reader.skipType(tag & 7);
1112
- break;
1113
- }
1114
- }
1115
- return message;
1116
- },
1117
- fromJSON(object) {
1118
- return {
1119
- intervalInMinutes: Array.isArray(object?.intervalInMinutes)
1120
- ? object.intervalInMinutes.map((e) => Number(e))
1121
- : [],
1122
- types: Array.isArray(object?.types) ? object.types.map((e) => aggregationTypeFromJSON(e)) : [],
1123
- discardOrigin: isSet(object.discardOrigin) ? Boolean(object.discardOrigin) : false,
1124
- };
1125
- },
1126
- toJSON(message) {
1127
- const obj = {};
1128
- if (message.intervalInMinutes) {
1129
- obj.intervalInMinutes = message.intervalInMinutes.map((e) => Math.round(e));
1130
- }
1131
- else {
1132
- obj.intervalInMinutes = [];
1133
- }
1134
- if (message.types) {
1135
- obj.types = message.types.map((e) => aggregationTypeToJSON(e));
1136
- }
1137
- else {
1138
- obj.types = [];
1139
- }
1140
- message.discardOrigin !== undefined && (obj.discardOrigin = message.discardOrigin);
1141
- return obj;
1142
- },
1143
- fromPartial(object) {
1144
- const message = createBaseAggregationConfig();
1145
- message.intervalInMinutes = object.intervalInMinutes?.map((e) => e) || [];
1146
- message.types = object.types?.map((e) => e) || [];
1147
- message.discardOrigin = object.discardOrigin ?? false;
1148
- return message;
1149
- },
1150
- };
1151
- function createBaseAccountConfig() {
1152
- return {
1153
- chainId: "",
1154
- address: "",
1155
- startBlock: long_1.default.UZERO,
1156
- intervalConfigs: [],
1157
- aptosIntervalConfigs: [],
1158
- logConfigs: [],
1159
- };
1160
- }
1161
- exports.AccountConfig = {
1162
- encode(message, writer = minimal_1.default.Writer.create()) {
1163
- if (message.chainId !== "") {
1164
- writer.uint32(10).string(message.chainId);
1165
- }
1166
- if (message.address !== "") {
1167
- writer.uint32(18).string(message.address);
1168
- }
1169
- if (!message.startBlock.isZero()) {
1170
- writer.uint32(24).uint64(message.startBlock);
1171
- }
1172
- for (const v of message.intervalConfigs) {
1173
- exports.OnIntervalConfig.encode(v, writer.uint32(34).fork()).ldelim();
1174
- }
1175
- for (const v of message.aptosIntervalConfigs) {
1176
- exports.AptosOnIntervalConfig.encode(v, writer.uint32(42).fork()).ldelim();
1177
- }
1178
- for (const v of message.logConfigs) {
1179
- exports.LogHandlerConfig.encode(v, writer.uint32(50).fork()).ldelim();
1180
- }
1181
- return writer;
1182
- },
1183
- decode(input, length) {
1184
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1185
- let end = length === undefined ? reader.len : reader.pos + length;
1186
- const message = createBaseAccountConfig();
1187
- while (reader.pos < end) {
1188
- const tag = reader.uint32();
1189
- switch (tag >>> 3) {
1190
- case 1:
1191
- message.chainId = reader.string();
1192
- break;
1193
- case 2:
1194
- message.address = reader.string();
1195
- break;
1196
- case 3:
1197
- message.startBlock = reader.uint64();
1198
- break;
1199
- case 4:
1200
- message.intervalConfigs.push(exports.OnIntervalConfig.decode(reader, reader.uint32()));
1201
- break;
1202
- case 5:
1203
- message.aptosIntervalConfigs.push(exports.AptosOnIntervalConfig.decode(reader, reader.uint32()));
1204
- break;
1205
- case 6:
1206
- message.logConfigs.push(exports.LogHandlerConfig.decode(reader, reader.uint32()));
1207
- break;
1208
- default:
1209
- reader.skipType(tag & 7);
1210
- break;
1211
- }
1212
- }
1213
- return message;
1214
- },
1215
- fromJSON(object) {
1216
- return {
1217
- chainId: isSet(object.chainId) ? String(object.chainId) : "",
1218
- address: isSet(object.address) ? String(object.address) : "",
1219
- startBlock: isSet(object.startBlock) ? long_1.default.fromValue(object.startBlock) : long_1.default.UZERO,
1220
- intervalConfigs: Array.isArray(object?.intervalConfigs)
1221
- ? object.intervalConfigs.map((e) => exports.OnIntervalConfig.fromJSON(e))
1222
- : [],
1223
- aptosIntervalConfigs: Array.isArray(object?.aptosIntervalConfigs)
1224
- ? object.aptosIntervalConfigs.map((e) => exports.AptosOnIntervalConfig.fromJSON(e))
1225
- : [],
1226
- logConfigs: Array.isArray(object?.logConfigs)
1227
- ? object.logConfigs.map((e) => exports.LogHandlerConfig.fromJSON(e))
1228
- : [],
1229
- };
1230
- },
1231
- toJSON(message) {
1232
- const obj = {};
1233
- message.chainId !== undefined && (obj.chainId = message.chainId);
1234
- message.address !== undefined && (obj.address = message.address);
1235
- message.startBlock !== undefined && (obj.startBlock = (message.startBlock || long_1.default.UZERO).toString());
1236
- if (message.intervalConfigs) {
1237
- obj.intervalConfigs = message.intervalConfigs.map((e) => e ? exports.OnIntervalConfig.toJSON(e) : undefined);
1238
- }
1239
- else {
1240
- obj.intervalConfigs = [];
1241
- }
1242
- if (message.aptosIntervalConfigs) {
1243
- obj.aptosIntervalConfigs = message.aptosIntervalConfigs.map((e) => e ? exports.AptosOnIntervalConfig.toJSON(e) : undefined);
1244
- }
1245
- else {
1246
- obj.aptosIntervalConfigs = [];
1247
- }
1248
- if (message.logConfigs) {
1249
- obj.logConfigs = message.logConfigs.map((e) => e ? exports.LogHandlerConfig.toJSON(e) : undefined);
1250
- }
1251
- else {
1252
- obj.logConfigs = [];
1253
- }
1254
- return obj;
1255
- },
1256
- fromPartial(object) {
1257
- const message = createBaseAccountConfig();
1258
- message.chainId = object.chainId ?? "";
1259
- message.address = object.address ?? "";
1260
- message.startBlock = (object.startBlock !== undefined && object.startBlock !== null)
1261
- ? long_1.default.fromValue(object.startBlock)
1262
- : long_1.default.UZERO;
1263
- message.intervalConfigs = object.intervalConfigs?.map((e) => exports.OnIntervalConfig.fromPartial(e)) || [];
1264
- message.aptosIntervalConfigs = object.aptosIntervalConfigs?.map((e) => exports.AptosOnIntervalConfig.fromPartial(e)) || [];
1265
- message.logConfigs = object.logConfigs?.map((e) => exports.LogHandlerConfig.fromPartial(e)) || [];
1266
- return message;
1267
- },
1268
- };
1269
- function createBaseHandleInterval() {
1270
- return { recentInterval: 0, backfillInterval: 0 };
1271
- }
1272
- exports.HandleInterval = {
1273
- encode(message, writer = minimal_1.default.Writer.create()) {
1274
- if (message.recentInterval !== 0) {
1275
- writer.uint32(8).int32(message.recentInterval);
1276
- }
1277
- if (message.backfillInterval !== 0) {
1278
- writer.uint32(16).int32(message.backfillInterval);
1279
- }
1280
- return writer;
1281
- },
1282
- decode(input, length) {
1283
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1284
- let end = length === undefined ? reader.len : reader.pos + length;
1285
- const message = createBaseHandleInterval();
1286
- while (reader.pos < end) {
1287
- const tag = reader.uint32();
1288
- switch (tag >>> 3) {
1289
- case 1:
1290
- message.recentInterval = reader.int32();
1291
- break;
1292
- case 2:
1293
- message.backfillInterval = reader.int32();
1294
- break;
1295
- default:
1296
- reader.skipType(tag & 7);
1297
- break;
1298
- }
1299
- }
1300
- return message;
1301
- },
1302
- fromJSON(object) {
1303
- return {
1304
- recentInterval: isSet(object.recentInterval) ? Number(object.recentInterval) : 0,
1305
- backfillInterval: isSet(object.backfillInterval) ? Number(object.backfillInterval) : 0,
1306
- };
1307
- },
1308
- toJSON(message) {
1309
- const obj = {};
1310
- message.recentInterval !== undefined && (obj.recentInterval = Math.round(message.recentInterval));
1311
- message.backfillInterval !== undefined && (obj.backfillInterval = Math.round(message.backfillInterval));
1312
- return obj;
1313
- },
1314
- fromPartial(object) {
1315
- const message = createBaseHandleInterval();
1316
- message.recentInterval = object.recentInterval ?? 0;
1317
- message.backfillInterval = object.backfillInterval ?? 0;
1318
- return message;
1319
- },
1320
- };
1321
- function createBaseOnIntervalConfig() {
1322
- return { handlerId: 0, minutes: 0, minutesInterval: undefined, slot: 0, slotInterval: undefined };
1323
- }
1324
- exports.OnIntervalConfig = {
1325
- encode(message, writer = minimal_1.default.Writer.create()) {
1326
- if (message.handlerId !== 0) {
1327
- writer.uint32(8).int32(message.handlerId);
1328
- }
1329
- if (message.minutes !== 0) {
1330
- writer.uint32(16).int32(message.minutes);
1331
- }
1332
- if (message.minutesInterval !== undefined) {
1333
- exports.HandleInterval.encode(message.minutesInterval, writer.uint32(34).fork()).ldelim();
1334
- }
1335
- if (message.slot !== 0) {
1336
- writer.uint32(24).int32(message.slot);
1337
- }
1338
- if (message.slotInterval !== undefined) {
1339
- exports.HandleInterval.encode(message.slotInterval, writer.uint32(42).fork()).ldelim();
1340
- }
1341
- return writer;
1342
- },
1343
- decode(input, length) {
1344
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1345
- let end = length === undefined ? reader.len : reader.pos + length;
1346
- const message = createBaseOnIntervalConfig();
1347
- while (reader.pos < end) {
1348
- const tag = reader.uint32();
1349
- switch (tag >>> 3) {
1350
- case 1:
1351
- message.handlerId = reader.int32();
1352
- break;
1353
- case 2:
1354
- message.minutes = reader.int32();
1355
- break;
1356
- case 4:
1357
- message.minutesInterval = exports.HandleInterval.decode(reader, reader.uint32());
1358
- break;
1359
- case 3:
1360
- message.slot = reader.int32();
1361
- break;
1362
- case 5:
1363
- message.slotInterval = exports.HandleInterval.decode(reader, reader.uint32());
1364
- break;
1365
- default:
1366
- reader.skipType(tag & 7);
1367
- break;
1368
- }
1369
- }
1370
- return message;
1371
- },
1372
- fromJSON(object) {
1373
- return {
1374
- handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
1375
- minutes: isSet(object.minutes) ? Number(object.minutes) : 0,
1376
- minutesInterval: isSet(object.minutesInterval) ? exports.HandleInterval.fromJSON(object.minutesInterval) : undefined,
1377
- slot: isSet(object.slot) ? Number(object.slot) : 0,
1378
- slotInterval: isSet(object.slotInterval) ? exports.HandleInterval.fromJSON(object.slotInterval) : undefined,
1379
- };
1380
- },
1381
- toJSON(message) {
1382
- const obj = {};
1383
- message.handlerId !== undefined && (obj.handlerId = Math.round(message.handlerId));
1384
- message.minutes !== undefined && (obj.minutes = Math.round(message.minutes));
1385
- message.minutesInterval !== undefined &&
1386
- (obj.minutesInterval = message.minutesInterval ? exports.HandleInterval.toJSON(message.minutesInterval) : undefined);
1387
- message.slot !== undefined && (obj.slot = Math.round(message.slot));
1388
- message.slotInterval !== undefined &&
1389
- (obj.slotInterval = message.slotInterval ? exports.HandleInterval.toJSON(message.slotInterval) : undefined);
1390
- return obj;
1391
- },
1392
- fromPartial(object) {
1393
- const message = createBaseOnIntervalConfig();
1394
- message.handlerId = object.handlerId ?? 0;
1395
- message.minutes = object.minutes ?? 0;
1396
- message.minutesInterval = (object.minutesInterval !== undefined && object.minutesInterval !== null)
1397
- ? exports.HandleInterval.fromPartial(object.minutesInterval)
1398
- : undefined;
1399
- message.slot = object.slot ?? 0;
1400
- message.slotInterval = (object.slotInterval !== undefined && object.slotInterval !== null)
1401
- ? exports.HandleInterval.fromPartial(object.slotInterval)
1402
- : undefined;
1403
- return message;
1404
- },
1405
- };
1406
- function createBaseAptosOnIntervalConfig() {
1407
- return { intervalConfig: undefined, type: "" };
1408
- }
1409
- exports.AptosOnIntervalConfig = {
1410
- encode(message, writer = minimal_1.default.Writer.create()) {
1411
- if (message.intervalConfig !== undefined) {
1412
- exports.OnIntervalConfig.encode(message.intervalConfig, writer.uint32(10).fork()).ldelim();
1413
- }
1414
- if (message.type !== "") {
1415
- writer.uint32(18).string(message.type);
1416
- }
1417
- return writer;
1418
- },
1419
- decode(input, length) {
1420
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1421
- let end = length === undefined ? reader.len : reader.pos + length;
1422
- const message = createBaseAptosOnIntervalConfig();
1423
- while (reader.pos < end) {
1424
- const tag = reader.uint32();
1425
- switch (tag >>> 3) {
1426
- case 1:
1427
- message.intervalConfig = exports.OnIntervalConfig.decode(reader, reader.uint32());
1428
- break;
1429
- case 2:
1430
- message.type = reader.string();
1431
- break;
1432
- default:
1433
- reader.skipType(tag & 7);
1434
- break;
1435
- }
1436
- }
1437
- return message;
1438
- },
1439
- fromJSON(object) {
1440
- return {
1441
- intervalConfig: isSet(object.intervalConfig) ? exports.OnIntervalConfig.fromJSON(object.intervalConfig) : undefined,
1442
- type: isSet(object.type) ? String(object.type) : "",
1443
- };
1444
- },
1445
- toJSON(message) {
1446
- const obj = {};
1447
- message.intervalConfig !== undefined &&
1448
- (obj.intervalConfig = message.intervalConfig ? exports.OnIntervalConfig.toJSON(message.intervalConfig) : undefined);
1449
- message.type !== undefined && (obj.type = message.type);
1450
- return obj;
1451
- },
1452
- fromPartial(object) {
1453
- const message = createBaseAptosOnIntervalConfig();
1454
- message.intervalConfig = (object.intervalConfig !== undefined && object.intervalConfig !== null)
1455
- ? exports.OnIntervalConfig.fromPartial(object.intervalConfig)
1456
- : undefined;
1457
- message.type = object.type ?? "";
1458
- return message;
1459
- },
1460
- };
1461
- function createBaseContractInfo() {
1462
- return { name: "", chainId: "", address: "", abi: "" };
1463
- }
1464
- exports.ContractInfo = {
1465
- encode(message, writer = minimal_1.default.Writer.create()) {
1466
- if (message.name !== "") {
1467
- writer.uint32(10).string(message.name);
1468
- }
1469
- if (message.chainId !== "") {
1470
- writer.uint32(18).string(message.chainId);
1471
- }
1472
- if (message.address !== "") {
1473
- writer.uint32(26).string(message.address);
1474
- }
1475
- if (message.abi !== "") {
1476
- writer.uint32(34).string(message.abi);
1477
- }
1478
- return writer;
1479
- },
1480
- decode(input, length) {
1481
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1482
- let end = length === undefined ? reader.len : reader.pos + length;
1483
- const message = createBaseContractInfo();
1484
- while (reader.pos < end) {
1485
- const tag = reader.uint32();
1486
- switch (tag >>> 3) {
1487
- case 1:
1488
- message.name = reader.string();
1489
- break;
1490
- case 2:
1491
- message.chainId = reader.string();
1492
- break;
1493
- case 3:
1494
- message.address = reader.string();
1495
- break;
1496
- case 4:
1497
- message.abi = reader.string();
1498
- break;
1499
- default:
1500
- reader.skipType(tag & 7);
1501
- break;
1502
- }
1503
- }
1504
- return message;
1505
- },
1506
- fromJSON(object) {
1507
- return {
1508
- name: isSet(object.name) ? String(object.name) : "",
1509
- chainId: isSet(object.chainId) ? String(object.chainId) : "",
1510
- address: isSet(object.address) ? String(object.address) : "",
1511
- abi: isSet(object.abi) ? String(object.abi) : "",
1512
- };
1513
- },
1514
- toJSON(message) {
1515
- const obj = {};
1516
- message.name !== undefined && (obj.name = message.name);
1517
- message.chainId !== undefined && (obj.chainId = message.chainId);
1518
- message.address !== undefined && (obj.address = message.address);
1519
- message.abi !== undefined && (obj.abi = message.abi);
1520
- return obj;
1521
- },
1522
- fromPartial(object) {
1523
- const message = createBaseContractInfo();
1524
- message.name = object.name ?? "";
1525
- message.chainId = object.chainId ?? "";
1526
- message.address = object.address ?? "";
1527
- message.abi = object.abi ?? "";
1528
- return message;
1529
- },
1530
- };
1531
- function createBaseTemplateInstance() {
1532
- return { contract: undefined, startBlock: long_1.default.UZERO, endBlock: long_1.default.UZERO, templateId: 0 };
1533
- }
1534
- exports.TemplateInstance = {
1535
- encode(message, writer = minimal_1.default.Writer.create()) {
1536
- if (message.contract !== undefined) {
1537
- exports.ContractInfo.encode(message.contract, writer.uint32(10).fork()).ldelim();
1538
- }
1539
- if (!message.startBlock.isZero()) {
1540
- writer.uint32(16).uint64(message.startBlock);
1541
- }
1542
- if (!message.endBlock.isZero()) {
1543
- writer.uint32(24).uint64(message.endBlock);
1544
- }
1545
- if (message.templateId !== 0) {
1546
- writer.uint32(32).int32(message.templateId);
1547
- }
1548
- return writer;
1549
- },
1550
- decode(input, length) {
1551
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1552
- let end = length === undefined ? reader.len : reader.pos + length;
1553
- const message = createBaseTemplateInstance();
1554
- while (reader.pos < end) {
1555
- const tag = reader.uint32();
1556
- switch (tag >>> 3) {
1557
- case 1:
1558
- message.contract = exports.ContractInfo.decode(reader, reader.uint32());
1559
- break;
1560
- case 2:
1561
- message.startBlock = reader.uint64();
1562
- break;
1563
- case 3:
1564
- message.endBlock = reader.uint64();
1565
- break;
1566
- case 4:
1567
- message.templateId = reader.int32();
1568
- break;
1569
- default:
1570
- reader.skipType(tag & 7);
1571
- break;
1572
- }
1573
- }
1574
- return message;
1575
- },
1576
- fromJSON(object) {
1577
- return {
1578
- contract: isSet(object.contract) ? exports.ContractInfo.fromJSON(object.contract) : undefined,
1579
- startBlock: isSet(object.startBlock) ? long_1.default.fromValue(object.startBlock) : long_1.default.UZERO,
1580
- endBlock: isSet(object.endBlock) ? long_1.default.fromValue(object.endBlock) : long_1.default.UZERO,
1581
- templateId: isSet(object.templateId) ? Number(object.templateId) : 0,
1582
- };
1583
- },
1584
- toJSON(message) {
1585
- const obj = {};
1586
- message.contract !== undefined &&
1587
- (obj.contract = message.contract ? exports.ContractInfo.toJSON(message.contract) : undefined);
1588
- message.startBlock !== undefined && (obj.startBlock = (message.startBlock || long_1.default.UZERO).toString());
1589
- message.endBlock !== undefined && (obj.endBlock = (message.endBlock || long_1.default.UZERO).toString());
1590
- message.templateId !== undefined && (obj.templateId = Math.round(message.templateId));
1591
- return obj;
1592
- },
1593
- fromPartial(object) {
1594
- const message = createBaseTemplateInstance();
1595
- message.contract = (object.contract !== undefined && object.contract !== null)
1596
- ? exports.ContractInfo.fromPartial(object.contract)
1597
- : undefined;
1598
- message.startBlock = (object.startBlock !== undefined && object.startBlock !== null)
1599
- ? long_1.default.fromValue(object.startBlock)
1600
- : long_1.default.UZERO;
1601
- message.endBlock = (object.endBlock !== undefined && object.endBlock !== null)
1602
- ? long_1.default.fromValue(object.endBlock)
1603
- : long_1.default.UZERO;
1604
- message.templateId = object.templateId ?? 0;
1605
- return message;
1606
- },
1607
- };
1608
- function createBaseStartRequest() {
1609
- return { templateInstances: [] };
1610
- }
1611
- exports.StartRequest = {
1612
- encode(message, writer = minimal_1.default.Writer.create()) {
1613
- for (const v of message.templateInstances) {
1614
- exports.TemplateInstance.encode(v, writer.uint32(10).fork()).ldelim();
1615
- }
1616
- return writer;
1617
- },
1618
- decode(input, length) {
1619
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1620
- let end = length === undefined ? reader.len : reader.pos + length;
1621
- const message = createBaseStartRequest();
1622
- while (reader.pos < end) {
1623
- const tag = reader.uint32();
1624
- switch (tag >>> 3) {
1625
- case 1:
1626
- message.templateInstances.push(exports.TemplateInstance.decode(reader, reader.uint32()));
1627
- break;
1628
- default:
1629
- reader.skipType(tag & 7);
1630
- break;
1631
- }
1632
- }
1633
- return message;
1634
- },
1635
- fromJSON(object) {
1636
- return {
1637
- templateInstances: Array.isArray(object?.templateInstances)
1638
- ? object.templateInstances.map((e) => exports.TemplateInstance.fromJSON(e))
1639
- : [],
1640
- };
1641
- },
1642
- toJSON(message) {
1643
- const obj = {};
1644
- if (message.templateInstances) {
1645
- obj.templateInstances = message.templateInstances.map((e) => e ? exports.TemplateInstance.toJSON(e) : undefined);
1646
- }
1647
- else {
1648
- obj.templateInstances = [];
1649
- }
1650
- return obj;
1651
- },
1652
- fromPartial(object) {
1653
- const message = createBaseStartRequest();
1654
- message.templateInstances = object.templateInstances?.map((e) => exports.TemplateInstance.fromPartial(e)) || [];
1655
- return message;
1656
- },
1657
- };
1658
- function createBaseBlockHandlerConfig() {
1659
- return { handlerId: 0 };
1660
- }
1661
- exports.BlockHandlerConfig = {
1662
- encode(message, writer = minimal_1.default.Writer.create()) {
1663
- if (message.handlerId !== 0) {
1664
- writer.uint32(8).int32(message.handlerId);
1665
- }
1666
- return writer;
1667
- },
1668
- decode(input, length) {
1669
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1670
- let end = length === undefined ? reader.len : reader.pos + length;
1671
- const message = createBaseBlockHandlerConfig();
1672
- while (reader.pos < end) {
1673
- const tag = reader.uint32();
1674
- switch (tag >>> 3) {
1675
- case 1:
1676
- message.handlerId = reader.int32();
1677
- break;
1678
- default:
1679
- reader.skipType(tag & 7);
1680
- break;
1681
- }
1682
- }
1683
- return message;
1684
- },
1685
- fromJSON(object) {
1686
- return { handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0 };
1687
- },
1688
- toJSON(message) {
1689
- const obj = {};
1690
- message.handlerId !== undefined && (obj.handlerId = Math.round(message.handlerId));
1691
- return obj;
1692
- },
1693
- fromPartial(object) {
1694
- const message = createBaseBlockHandlerConfig();
1695
- message.handlerId = object.handlerId ?? 0;
1696
- return message;
1697
- },
1698
- };
1699
- function createBaseTraceHandlerConfig() {
1700
- return { signature: "", handlerId: 0 };
1701
- }
1702
- exports.TraceHandlerConfig = {
1703
- encode(message, writer = minimal_1.default.Writer.create()) {
1704
- if (message.signature !== "") {
1705
- writer.uint32(10).string(message.signature);
1706
- }
1707
- if (message.handlerId !== 0) {
1708
- writer.uint32(16).int32(message.handlerId);
1709
- }
1710
- return writer;
1711
- },
1712
- decode(input, length) {
1713
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1714
- let end = length === undefined ? reader.len : reader.pos + length;
1715
- const message = createBaseTraceHandlerConfig();
1716
- while (reader.pos < end) {
1717
- const tag = reader.uint32();
1718
- switch (tag >>> 3) {
1719
- case 1:
1720
- message.signature = reader.string();
1721
- break;
1722
- case 2:
1723
- message.handlerId = reader.int32();
1724
- break;
1725
- default:
1726
- reader.skipType(tag & 7);
1727
- break;
1728
- }
1729
- }
1730
- return message;
1731
- },
1732
- fromJSON(object) {
1733
- return {
1734
- signature: isSet(object.signature) ? String(object.signature) : "",
1735
- handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
1736
- };
1737
- },
1738
- toJSON(message) {
1739
- const obj = {};
1740
- message.signature !== undefined && (obj.signature = message.signature);
1741
- message.handlerId !== undefined && (obj.handlerId = Math.round(message.handlerId));
1742
- return obj;
1743
- },
1744
- fromPartial(object) {
1745
- const message = createBaseTraceHandlerConfig();
1746
- message.signature = object.signature ?? "";
1747
- message.handlerId = object.handlerId ?? 0;
1748
- return message;
1749
- },
1750
- };
1751
- function createBaseLogHandlerConfig() {
1752
- return { filters: [], handlerId: 0 };
1753
- }
1754
- exports.LogHandlerConfig = {
1755
- encode(message, writer = minimal_1.default.Writer.create()) {
1756
- for (const v of message.filters) {
1757
- exports.LogFilter.encode(v, writer.uint32(10).fork()).ldelim();
1758
- }
1759
- if (message.handlerId !== 0) {
1760
- writer.uint32(16).int32(message.handlerId);
1761
- }
1762
- return writer;
1763
- },
1764
- decode(input, length) {
1765
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1766
- let end = length === undefined ? reader.len : reader.pos + length;
1767
- const message = createBaseLogHandlerConfig();
1768
- while (reader.pos < end) {
1769
- const tag = reader.uint32();
1770
- switch (tag >>> 3) {
1771
- case 1:
1772
- message.filters.push(exports.LogFilter.decode(reader, reader.uint32()));
1773
- break;
1774
- case 2:
1775
- message.handlerId = reader.int32();
1776
- break;
1777
- default:
1778
- reader.skipType(tag & 7);
1779
- break;
1780
- }
1781
- }
1782
- return message;
1783
- },
1784
- fromJSON(object) {
1785
- return {
1786
- filters: Array.isArray(object?.filters) ? object.filters.map((e) => exports.LogFilter.fromJSON(e)) : [],
1787
- handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
1788
- };
1789
- },
1790
- toJSON(message) {
1791
- const obj = {};
1792
- if (message.filters) {
1793
- obj.filters = message.filters.map((e) => e ? exports.LogFilter.toJSON(e) : undefined);
1794
- }
1795
- else {
1796
- obj.filters = [];
1797
- }
1798
- message.handlerId !== undefined && (obj.handlerId = Math.round(message.handlerId));
1799
- return obj;
1800
- },
1801
- fromPartial(object) {
1802
- const message = createBaseLogHandlerConfig();
1803
- message.filters = object.filters?.map((e) => exports.LogFilter.fromPartial(e)) || [];
1804
- message.handlerId = object.handlerId ?? 0;
1805
- return message;
1806
- },
1807
- };
1808
- function createBaseLogFilter() {
1809
- return { topics: [], address: undefined, addressType: undefined };
1810
- }
1811
- exports.LogFilter = {
1812
- encode(message, writer = minimal_1.default.Writer.create()) {
1813
- for (const v of message.topics) {
1814
- exports.Topic.encode(v, writer.uint32(10).fork()).ldelim();
1815
- }
1816
- if (message.address !== undefined) {
1817
- writer.uint32(18).string(message.address);
1818
- }
1819
- if (message.addressType !== undefined) {
1820
- writer.uint32(24).int32(message.addressType);
1821
- }
1822
- return writer;
1823
- },
1824
- decode(input, length) {
1825
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1826
- let end = length === undefined ? reader.len : reader.pos + length;
1827
- const message = createBaseLogFilter();
1828
- while (reader.pos < end) {
1829
- const tag = reader.uint32();
1830
- switch (tag >>> 3) {
1831
- case 1:
1832
- message.topics.push(exports.Topic.decode(reader, reader.uint32()));
1833
- break;
1834
- case 2:
1835
- message.address = reader.string();
1836
- break;
1837
- case 3:
1838
- message.addressType = reader.int32();
1839
- break;
1840
- default:
1841
- reader.skipType(tag & 7);
1842
- break;
1843
- }
1844
- }
1845
- return message;
1846
- },
1847
- fromJSON(object) {
1848
- return {
1849
- topics: Array.isArray(object?.topics) ? object.topics.map((e) => exports.Topic.fromJSON(e)) : [],
1850
- address: isSet(object.address) ? String(object.address) : undefined,
1851
- addressType: isSet(object.addressType) ? addressTypeFromJSON(object.addressType) : undefined,
1852
- };
1853
- },
1854
- toJSON(message) {
1855
- const obj = {};
1856
- if (message.topics) {
1857
- obj.topics = message.topics.map((e) => e ? exports.Topic.toJSON(e) : undefined);
1858
- }
1859
- else {
1860
- obj.topics = [];
1861
- }
1862
- message.address !== undefined && (obj.address = message.address);
1863
- message.addressType !== undefined &&
1864
- (obj.addressType = message.addressType !== undefined ? addressTypeToJSON(message.addressType) : undefined);
1865
- return obj;
1866
- },
1867
- fromPartial(object) {
1868
- const message = createBaseLogFilter();
1869
- message.topics = object.topics?.map((e) => exports.Topic.fromPartial(e)) || [];
1870
- message.address = object.address ?? undefined;
1871
- message.addressType = object.addressType ?? undefined;
1872
- return message;
1873
- },
1874
- };
1875
- function createBaseInstructionHandlerConfig() {
1876
- return { innerInstruction: false, parsedInstruction: false, rawDataInstruction: false };
1877
- }
1878
- exports.InstructionHandlerConfig = {
1879
- encode(message, writer = minimal_1.default.Writer.create()) {
1880
- if (message.innerInstruction === true) {
1881
- writer.uint32(8).bool(message.innerInstruction);
1882
- }
1883
- if (message.parsedInstruction === true) {
1884
- writer.uint32(16).bool(message.parsedInstruction);
1885
- }
1886
- if (message.rawDataInstruction === true) {
1887
- writer.uint32(24).bool(message.rawDataInstruction);
1888
- }
1889
- return writer;
1890
- },
1891
- decode(input, length) {
1892
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1893
- let end = length === undefined ? reader.len : reader.pos + length;
1894
- const message = createBaseInstructionHandlerConfig();
1895
- while (reader.pos < end) {
1896
- const tag = reader.uint32();
1897
- switch (tag >>> 3) {
1898
- case 1:
1899
- message.innerInstruction = reader.bool();
1900
- break;
1901
- case 2:
1902
- message.parsedInstruction = reader.bool();
1903
- break;
1904
- case 3:
1905
- message.rawDataInstruction = reader.bool();
1906
- break;
1907
- default:
1908
- reader.skipType(tag & 7);
1909
- break;
1910
- }
1911
- }
1912
- return message;
1913
- },
1914
- fromJSON(object) {
1915
- return {
1916
- innerInstruction: isSet(object.innerInstruction) ? Boolean(object.innerInstruction) : false,
1917
- parsedInstruction: isSet(object.parsedInstruction) ? Boolean(object.parsedInstruction) : false,
1918
- rawDataInstruction: isSet(object.rawDataInstruction) ? Boolean(object.rawDataInstruction) : false,
1919
- };
1920
- },
1921
- toJSON(message) {
1922
- const obj = {};
1923
- message.innerInstruction !== undefined && (obj.innerInstruction = message.innerInstruction);
1924
- message.parsedInstruction !== undefined && (obj.parsedInstruction = message.parsedInstruction);
1925
- message.rawDataInstruction !== undefined && (obj.rawDataInstruction = message.rawDataInstruction);
1926
- return obj;
1927
- },
1928
- fromPartial(object) {
1929
- const message = createBaseInstructionHandlerConfig();
1930
- message.innerInstruction = object.innerInstruction ?? false;
1931
- message.parsedInstruction = object.parsedInstruction ?? false;
1932
- message.rawDataInstruction = object.rawDataInstruction ?? false;
1933
- return message;
1934
- },
1935
- };
1936
- function createBaseAptosEventHandlerConfig() {
1937
- return { filters: [], handlerId: 0 };
1938
- }
1939
- exports.AptosEventHandlerConfig = {
1940
- encode(message, writer = minimal_1.default.Writer.create()) {
1941
- for (const v of message.filters) {
1942
- exports.AptosEventFilter.encode(v, writer.uint32(10).fork()).ldelim();
1943
- }
1944
- if (message.handlerId !== 0) {
1945
- writer.uint32(16).int32(message.handlerId);
1946
- }
1947
- return writer;
1948
- },
1949
- decode(input, length) {
1950
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
1951
- let end = length === undefined ? reader.len : reader.pos + length;
1952
- const message = createBaseAptosEventHandlerConfig();
1953
- while (reader.pos < end) {
1954
- const tag = reader.uint32();
1955
- switch (tag >>> 3) {
1956
- case 1:
1957
- message.filters.push(exports.AptosEventFilter.decode(reader, reader.uint32()));
1958
- break;
1959
- case 2:
1960
- message.handlerId = reader.int32();
1961
- break;
1962
- default:
1963
- reader.skipType(tag & 7);
1964
- break;
1965
- }
1966
- }
1967
- return message;
1968
- },
1969
- fromJSON(object) {
1970
- return {
1971
- filters: Array.isArray(object?.filters) ? object.filters.map((e) => exports.AptosEventFilter.fromJSON(e)) : [],
1972
- handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
1973
- };
1974
- },
1975
- toJSON(message) {
1976
- const obj = {};
1977
- if (message.filters) {
1978
- obj.filters = message.filters.map((e) => e ? exports.AptosEventFilter.toJSON(e) : undefined);
1979
- }
1980
- else {
1981
- obj.filters = [];
1982
- }
1983
- message.handlerId !== undefined && (obj.handlerId = Math.round(message.handlerId));
1984
- return obj;
1985
- },
1986
- fromPartial(object) {
1987
- const message = createBaseAptosEventHandlerConfig();
1988
- message.filters = object.filters?.map((e) => exports.AptosEventFilter.fromPartial(e)) || [];
1989
- message.handlerId = object.handlerId ?? 0;
1990
- return message;
1991
- },
1992
- };
1993
- function createBaseAptosEventFilter() {
1994
- return { type: "", account: "" };
1995
- }
1996
- exports.AptosEventFilter = {
1997
- encode(message, writer = minimal_1.default.Writer.create()) {
1998
- if (message.type !== "") {
1999
- writer.uint32(10).string(message.type);
2000
- }
2001
- if (message.account !== "") {
2002
- writer.uint32(18).string(message.account);
2003
- }
2004
- return writer;
2005
- },
2006
- decode(input, length) {
2007
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2008
- let end = length === undefined ? reader.len : reader.pos + length;
2009
- const message = createBaseAptosEventFilter();
2010
- while (reader.pos < end) {
2011
- const tag = reader.uint32();
2012
- switch (tag >>> 3) {
2013
- case 1:
2014
- message.type = reader.string();
2015
- break;
2016
- case 2:
2017
- message.account = reader.string();
2018
- break;
2019
- default:
2020
- reader.skipType(tag & 7);
2021
- break;
2022
- }
2023
- }
2024
- return message;
2025
- },
2026
- fromJSON(object) {
2027
- return {
2028
- type: isSet(object.type) ? String(object.type) : "",
2029
- account: isSet(object.account) ? String(object.account) : "",
2030
- };
2031
- },
2032
- toJSON(message) {
2033
- const obj = {};
2034
- message.type !== undefined && (obj.type = message.type);
2035
- message.account !== undefined && (obj.account = message.account);
2036
- return obj;
2037
- },
2038
- fromPartial(object) {
2039
- const message = createBaseAptosEventFilter();
2040
- message.type = object.type ?? "";
2041
- message.account = object.account ?? "";
2042
- return message;
2043
- },
2044
- };
2045
- function createBaseAptosCallHandlerConfig() {
2046
- return { filters: [], handlerId: 0 };
2047
- }
2048
- exports.AptosCallHandlerConfig = {
2049
- encode(message, writer = minimal_1.default.Writer.create()) {
2050
- for (const v of message.filters) {
2051
- exports.AptosCallFilter.encode(v, writer.uint32(10).fork()).ldelim();
2052
- }
2053
- if (message.handlerId !== 0) {
2054
- writer.uint32(16).int32(message.handlerId);
2055
- }
2056
- return writer;
2057
- },
2058
- decode(input, length) {
2059
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2060
- let end = length === undefined ? reader.len : reader.pos + length;
2061
- const message = createBaseAptosCallHandlerConfig();
2062
- while (reader.pos < end) {
2063
- const tag = reader.uint32();
2064
- switch (tag >>> 3) {
2065
- case 1:
2066
- message.filters.push(exports.AptosCallFilter.decode(reader, reader.uint32()));
2067
- break;
2068
- case 2:
2069
- message.handlerId = reader.int32();
2070
- break;
2071
- default:
2072
- reader.skipType(tag & 7);
2073
- break;
2074
- }
2075
- }
2076
- return message;
2077
- },
2078
- fromJSON(object) {
2079
- return {
2080
- filters: Array.isArray(object?.filters) ? object.filters.map((e) => exports.AptosCallFilter.fromJSON(e)) : [],
2081
- handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
2082
- };
2083
- },
2084
- toJSON(message) {
2085
- const obj = {};
2086
- if (message.filters) {
2087
- obj.filters = message.filters.map((e) => e ? exports.AptosCallFilter.toJSON(e) : undefined);
2088
- }
2089
- else {
2090
- obj.filters = [];
2091
- }
2092
- message.handlerId !== undefined && (obj.handlerId = Math.round(message.handlerId));
2093
- return obj;
2094
- },
2095
- fromPartial(object) {
2096
- const message = createBaseAptosCallHandlerConfig();
2097
- message.filters = object.filters?.map((e) => exports.AptosCallFilter.fromPartial(e)) || [];
2098
- message.handlerId = object.handlerId ?? 0;
2099
- return message;
2100
- },
2101
- };
2102
- function createBaseAptosCallFilter() {
2103
- return { function: "", typeArguments: [], withTypeArguments: false, includeFailed: false };
2104
- }
2105
- exports.AptosCallFilter = {
2106
- encode(message, writer = minimal_1.default.Writer.create()) {
2107
- if (message.function !== "") {
2108
- writer.uint32(10).string(message.function);
2109
- }
2110
- for (const v of message.typeArguments) {
2111
- writer.uint32(18).string(v);
2112
- }
2113
- if (message.withTypeArguments === true) {
2114
- writer.uint32(24).bool(message.withTypeArguments);
2115
- }
2116
- if (message.includeFailed === true) {
2117
- writer.uint32(32).bool(message.includeFailed);
2118
- }
2119
- return writer;
2120
- },
2121
- decode(input, length) {
2122
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2123
- let end = length === undefined ? reader.len : reader.pos + length;
2124
- const message = createBaseAptosCallFilter();
2125
- while (reader.pos < end) {
2126
- const tag = reader.uint32();
2127
- switch (tag >>> 3) {
2128
- case 1:
2129
- message.function = reader.string();
2130
- break;
2131
- case 2:
2132
- message.typeArguments.push(reader.string());
2133
- break;
2134
- case 3:
2135
- message.withTypeArguments = reader.bool();
2136
- break;
2137
- case 4:
2138
- message.includeFailed = reader.bool();
2139
- break;
2140
- default:
2141
- reader.skipType(tag & 7);
2142
- break;
2143
- }
2144
- }
2145
- return message;
2146
- },
2147
- fromJSON(object) {
2148
- return {
2149
- function: isSet(object.function) ? String(object.function) : "",
2150
- typeArguments: Array.isArray(object?.typeArguments) ? object.typeArguments.map((e) => String(e)) : [],
2151
- withTypeArguments: isSet(object.withTypeArguments) ? Boolean(object.withTypeArguments) : false,
2152
- includeFailed: isSet(object.includeFailed) ? Boolean(object.includeFailed) : false,
2153
- };
2154
- },
2155
- toJSON(message) {
2156
- const obj = {};
2157
- message.function !== undefined && (obj.function = message.function);
2158
- if (message.typeArguments) {
2159
- obj.typeArguments = message.typeArguments.map((e) => e);
2160
- }
2161
- else {
2162
- obj.typeArguments = [];
2163
- }
2164
- message.withTypeArguments !== undefined && (obj.withTypeArguments = message.withTypeArguments);
2165
- message.includeFailed !== undefined && (obj.includeFailed = message.includeFailed);
2166
- return obj;
2167
- },
2168
- fromPartial(object) {
2169
- const message = createBaseAptosCallFilter();
2170
- message.function = object.function ?? "";
2171
- message.typeArguments = object.typeArguments?.map((e) => e) || [];
2172
- message.withTypeArguments = object.withTypeArguments ?? false;
2173
- message.includeFailed = object.includeFailed ?? false;
2174
- return message;
2175
- },
2176
- };
2177
- function createBaseTopic() {
2178
- return { hashes: [] };
2179
- }
2180
- exports.Topic = {
2181
- encode(message, writer = minimal_1.default.Writer.create()) {
2182
- for (const v of message.hashes) {
2183
- writer.uint32(10).string(v);
2184
- }
2185
- return writer;
2186
- },
2187
- decode(input, length) {
2188
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2189
- let end = length === undefined ? reader.len : reader.pos + length;
2190
- const message = createBaseTopic();
2191
- while (reader.pos < end) {
2192
- const tag = reader.uint32();
2193
- switch (tag >>> 3) {
2194
- case 1:
2195
- message.hashes.push(reader.string());
2196
- break;
2197
- default:
2198
- reader.skipType(tag & 7);
2199
- break;
2200
- }
2201
- }
2202
- return message;
2203
- },
2204
- fromJSON(object) {
2205
- return { hashes: Array.isArray(object?.hashes) ? object.hashes.map((e) => String(e)) : [] };
2206
- },
2207
- toJSON(message) {
2208
- const obj = {};
2209
- if (message.hashes) {
2210
- obj.hashes = message.hashes.map((e) => e);
2211
- }
2212
- else {
2213
- obj.hashes = [];
2214
- }
2215
- return obj;
2216
- },
2217
- fromPartial(object) {
2218
- const message = createBaseTopic();
2219
- message.hashes = object.hashes?.map((e) => e) || [];
2220
- return message;
2221
- },
2222
- };
2223
- function createBaseProcessBindingsRequest() {
2224
- return { bindings: [] };
2225
- }
2226
- exports.ProcessBindingsRequest = {
2227
- encode(message, writer = minimal_1.default.Writer.create()) {
2228
- for (const v of message.bindings) {
2229
- exports.DataBinding.encode(v, writer.uint32(10).fork()).ldelim();
2230
- }
2231
- return writer;
2232
- },
2233
- decode(input, length) {
2234
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2235
- let end = length === undefined ? reader.len : reader.pos + length;
2236
- const message = createBaseProcessBindingsRequest();
2237
- while (reader.pos < end) {
2238
- const tag = reader.uint32();
2239
- switch (tag >>> 3) {
2240
- case 1:
2241
- message.bindings.push(exports.DataBinding.decode(reader, reader.uint32()));
2242
- break;
2243
- default:
2244
- reader.skipType(tag & 7);
2245
- break;
2246
- }
2247
- }
2248
- return message;
2249
- },
2250
- fromJSON(object) {
2251
- return {
2252
- bindings: Array.isArray(object?.bindings) ? object.bindings.map((e) => exports.DataBinding.fromJSON(e)) : [],
2253
- };
2254
- },
2255
- toJSON(message) {
2256
- const obj = {};
2257
- if (message.bindings) {
2258
- obj.bindings = message.bindings.map((e) => e ? exports.DataBinding.toJSON(e) : undefined);
2259
- }
2260
- else {
2261
- obj.bindings = [];
2262
- }
2263
- return obj;
2264
- },
2265
- fromPartial(object) {
2266
- const message = createBaseProcessBindingsRequest();
2267
- message.bindings = object.bindings?.map((e) => exports.DataBinding.fromPartial(e)) || [];
2268
- return message;
2269
- },
2270
- };
2271
- function createBaseProcessBindingResponse() {
2272
- return { result: undefined, configUpdated: false };
2273
- }
2274
- exports.ProcessBindingResponse = {
2275
- encode(message, writer = minimal_1.default.Writer.create()) {
2276
- if (message.result !== undefined) {
2277
- exports.ProcessResult.encode(message.result, writer.uint32(10).fork()).ldelim();
2278
- }
2279
- if (message.configUpdated === true) {
2280
- writer.uint32(32).bool(message.configUpdated);
2281
- }
2282
- return writer;
2283
- },
2284
- decode(input, length) {
2285
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2286
- let end = length === undefined ? reader.len : reader.pos + length;
2287
- const message = createBaseProcessBindingResponse();
2288
- while (reader.pos < end) {
2289
- const tag = reader.uint32();
2290
- switch (tag >>> 3) {
2291
- case 1:
2292
- message.result = exports.ProcessResult.decode(reader, reader.uint32());
2293
- break;
2294
- case 4:
2295
- message.configUpdated = reader.bool();
2296
- break;
2297
- default:
2298
- reader.skipType(tag & 7);
2299
- break;
2300
- }
2301
- }
2302
- return message;
2303
- },
2304
- fromJSON(object) {
2305
- return {
2306
- result: isSet(object.result) ? exports.ProcessResult.fromJSON(object.result) : undefined,
2307
- configUpdated: isSet(object.configUpdated) ? Boolean(object.configUpdated) : false,
2308
- };
2309
- },
2310
- toJSON(message) {
2311
- const obj = {};
2312
- message.result !== undefined && (obj.result = message.result ? exports.ProcessResult.toJSON(message.result) : undefined);
2313
- message.configUpdated !== undefined && (obj.configUpdated = message.configUpdated);
2314
- return obj;
2315
- },
2316
- fromPartial(object) {
2317
- const message = createBaseProcessBindingResponse();
2318
- message.result = (object.result !== undefined && object.result !== null)
2319
- ? exports.ProcessResult.fromPartial(object.result)
2320
- : undefined;
2321
- message.configUpdated = object.configUpdated ?? false;
2322
- return message;
2323
- },
2324
- };
2325
- function createBaseRawTransaction() {
2326
- return { raw: new Uint8Array(), programAccountId: undefined, slot: undefined };
2327
- }
2328
- exports.RawTransaction = {
2329
- encode(message, writer = minimal_1.default.Writer.create()) {
2330
- if (message.raw.length !== 0) {
2331
- writer.uint32(10).bytes(message.raw);
2332
- }
2333
- if (message.programAccountId !== undefined) {
2334
- writer.uint32(18).string(message.programAccountId);
2335
- }
2336
- if (message.slot !== undefined) {
2337
- writer.uint32(24).uint64(message.slot);
2338
- }
2339
- return writer;
2340
- },
2341
- decode(input, length) {
2342
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2343
- let end = length === undefined ? reader.len : reader.pos + length;
2344
- const message = createBaseRawTransaction();
2345
- while (reader.pos < end) {
2346
- const tag = reader.uint32();
2347
- switch (tag >>> 3) {
2348
- case 1:
2349
- message.raw = reader.bytes();
2350
- break;
2351
- case 2:
2352
- message.programAccountId = reader.string();
2353
- break;
2354
- case 3:
2355
- message.slot = reader.uint64();
2356
- break;
2357
- default:
2358
- reader.skipType(tag & 7);
2359
- break;
2360
- }
2361
- }
2362
- return message;
2363
- },
2364
- fromJSON(object) {
2365
- return {
2366
- raw: isSet(object.raw) ? bytesFromBase64(object.raw) : new Uint8Array(),
2367
- programAccountId: isSet(object.programAccountId) ? String(object.programAccountId) : undefined,
2368
- slot: isSet(object.slot) ? long_1.default.fromValue(object.slot) : undefined,
2369
- };
2370
- },
2371
- toJSON(message) {
2372
- const obj = {};
2373
- message.raw !== undefined &&
2374
- (obj.raw = base64FromBytes(message.raw !== undefined ? message.raw : new Uint8Array()));
2375
- message.programAccountId !== undefined && (obj.programAccountId = message.programAccountId);
2376
- message.slot !== undefined && (obj.slot = (message.slot || undefined).toString());
2377
- return obj;
2378
- },
2379
- fromPartial(object) {
2380
- const message = createBaseRawTransaction();
2381
- message.raw = object.raw ?? new Uint8Array();
2382
- message.programAccountId = object.programAccountId ?? undefined;
2383
- message.slot = (object.slot !== undefined && object.slot !== null) ? long_1.default.fromValue(object.slot) : undefined;
2384
- return message;
2385
- },
2386
- };
2387
- function createBaseData() {
2388
- return {
2389
- raw: new Uint8Array(),
2390
- ethLog: undefined,
2391
- ethBlock: undefined,
2392
- ethTransaction: undefined,
2393
- ethTrace: undefined,
2394
- solInstruction: undefined,
2395
- aptEvent: undefined,
2396
- aptCall: undefined,
2397
- aptResource: undefined,
2398
- };
2399
- }
2400
- exports.Data = {
2401
- encode(message, writer = minimal_1.default.Writer.create()) {
2402
- if (message.raw.length !== 0) {
2403
- writer.uint32(10).bytes(message.raw);
2404
- }
2405
- if (message.ethLog !== undefined) {
2406
- exports.Data_EthLog.encode(message.ethLog, writer.uint32(18).fork()).ldelim();
2407
- }
2408
- if (message.ethBlock !== undefined) {
2409
- exports.Data_EthBlock.encode(message.ethBlock, writer.uint32(26).fork()).ldelim();
2410
- }
2411
- if (message.ethTransaction !== undefined) {
2412
- exports.Data_EthTransaction.encode(message.ethTransaction, writer.uint32(34).fork()).ldelim();
2413
- }
2414
- if (message.ethTrace !== undefined) {
2415
- exports.Data_EthTrace.encode(message.ethTrace, writer.uint32(42).fork()).ldelim();
2416
- }
2417
- if (message.solInstruction !== undefined) {
2418
- exports.Data_SolInstruction.encode(message.solInstruction, writer.uint32(50).fork()).ldelim();
2419
- }
2420
- if (message.aptEvent !== undefined) {
2421
- exports.Data_AptEvent.encode(message.aptEvent, writer.uint32(58).fork()).ldelim();
2422
- }
2423
- if (message.aptCall !== undefined) {
2424
- exports.Data_AptCall.encode(message.aptCall, writer.uint32(66).fork()).ldelim();
2425
- }
2426
- if (message.aptResource !== undefined) {
2427
- exports.Data_AptResource.encode(message.aptResource, writer.uint32(74).fork()).ldelim();
2428
- }
2429
- return writer;
2430
- },
2431
- decode(input, length) {
2432
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2433
- let end = length === undefined ? reader.len : reader.pos + length;
2434
- const message = createBaseData();
2435
- while (reader.pos < end) {
2436
- const tag = reader.uint32();
2437
- switch (tag >>> 3) {
2438
- case 1:
2439
- message.raw = reader.bytes();
2440
- break;
2441
- case 2:
2442
- message.ethLog = exports.Data_EthLog.decode(reader, reader.uint32());
2443
- break;
2444
- case 3:
2445
- message.ethBlock = exports.Data_EthBlock.decode(reader, reader.uint32());
2446
- break;
2447
- case 4:
2448
- message.ethTransaction = exports.Data_EthTransaction.decode(reader, reader.uint32());
2449
- break;
2450
- case 5:
2451
- message.ethTrace = exports.Data_EthTrace.decode(reader, reader.uint32());
2452
- break;
2453
- case 6:
2454
- message.solInstruction = exports.Data_SolInstruction.decode(reader, reader.uint32());
2455
- break;
2456
- case 7:
2457
- message.aptEvent = exports.Data_AptEvent.decode(reader, reader.uint32());
2458
- break;
2459
- case 8:
2460
- message.aptCall = exports.Data_AptCall.decode(reader, reader.uint32());
2461
- break;
2462
- case 9:
2463
- message.aptResource = exports.Data_AptResource.decode(reader, reader.uint32());
2464
- break;
2465
- default:
2466
- reader.skipType(tag & 7);
2467
- break;
2468
- }
2469
- }
2470
- return message;
2471
- },
2472
- fromJSON(object) {
2473
- return {
2474
- raw: isSet(object.raw) ? bytesFromBase64(object.raw) : new Uint8Array(),
2475
- ethLog: isSet(object.ethLog) ? exports.Data_EthLog.fromJSON(object.ethLog) : undefined,
2476
- ethBlock: isSet(object.ethBlock) ? exports.Data_EthBlock.fromJSON(object.ethBlock) : undefined,
2477
- ethTransaction: isSet(object.ethTransaction) ? exports.Data_EthTransaction.fromJSON(object.ethTransaction) : undefined,
2478
- ethTrace: isSet(object.ethTrace) ? exports.Data_EthTrace.fromJSON(object.ethTrace) : undefined,
2479
- solInstruction: isSet(object.solInstruction) ? exports.Data_SolInstruction.fromJSON(object.solInstruction) : undefined,
2480
- aptEvent: isSet(object.aptEvent) ? exports.Data_AptEvent.fromJSON(object.aptEvent) : undefined,
2481
- aptCall: isSet(object.aptCall) ? exports.Data_AptCall.fromJSON(object.aptCall) : undefined,
2482
- aptResource: isSet(object.aptResource) ? exports.Data_AptResource.fromJSON(object.aptResource) : undefined,
2483
- };
2484
- },
2485
- toJSON(message) {
2486
- const obj = {};
2487
- message.raw !== undefined &&
2488
- (obj.raw = base64FromBytes(message.raw !== undefined ? message.raw : new Uint8Array()));
2489
- message.ethLog !== undefined && (obj.ethLog = message.ethLog ? exports.Data_EthLog.toJSON(message.ethLog) : undefined);
2490
- message.ethBlock !== undefined &&
2491
- (obj.ethBlock = message.ethBlock ? exports.Data_EthBlock.toJSON(message.ethBlock) : undefined);
2492
- message.ethTransaction !== undefined &&
2493
- (obj.ethTransaction = message.ethTransaction ? exports.Data_EthTransaction.toJSON(message.ethTransaction) : undefined);
2494
- message.ethTrace !== undefined &&
2495
- (obj.ethTrace = message.ethTrace ? exports.Data_EthTrace.toJSON(message.ethTrace) : undefined);
2496
- message.solInstruction !== undefined &&
2497
- (obj.solInstruction = message.solInstruction ? exports.Data_SolInstruction.toJSON(message.solInstruction) : undefined);
2498
- message.aptEvent !== undefined &&
2499
- (obj.aptEvent = message.aptEvent ? exports.Data_AptEvent.toJSON(message.aptEvent) : undefined);
2500
- message.aptCall !== undefined && (obj.aptCall = message.aptCall ? exports.Data_AptCall.toJSON(message.aptCall) : undefined);
2501
- message.aptResource !== undefined &&
2502
- (obj.aptResource = message.aptResource ? exports.Data_AptResource.toJSON(message.aptResource) : undefined);
2503
- return obj;
2504
- },
2505
- fromPartial(object) {
2506
- const message = createBaseData();
2507
- message.raw = object.raw ?? new Uint8Array();
2508
- message.ethLog = (object.ethLog !== undefined && object.ethLog !== null)
2509
- ? exports.Data_EthLog.fromPartial(object.ethLog)
2510
- : undefined;
2511
- message.ethBlock = (object.ethBlock !== undefined && object.ethBlock !== null)
2512
- ? exports.Data_EthBlock.fromPartial(object.ethBlock)
2513
- : undefined;
2514
- message.ethTransaction = (object.ethTransaction !== undefined && object.ethTransaction !== null)
2515
- ? exports.Data_EthTransaction.fromPartial(object.ethTransaction)
2516
- : undefined;
2517
- message.ethTrace = (object.ethTrace !== undefined && object.ethTrace !== null)
2518
- ? exports.Data_EthTrace.fromPartial(object.ethTrace)
2519
- : undefined;
2520
- message.solInstruction = (object.solInstruction !== undefined && object.solInstruction !== null)
2521
- ? exports.Data_SolInstruction.fromPartial(object.solInstruction)
2522
- : undefined;
2523
- message.aptEvent = (object.aptEvent !== undefined && object.aptEvent !== null)
2524
- ? exports.Data_AptEvent.fromPartial(object.aptEvent)
2525
- : undefined;
2526
- message.aptCall = (object.aptCall !== undefined && object.aptCall !== null)
2527
- ? exports.Data_AptCall.fromPartial(object.aptCall)
2528
- : undefined;
2529
- message.aptResource = (object.aptResource !== undefined && object.aptResource !== null)
2530
- ? exports.Data_AptResource.fromPartial(object.aptResource)
2531
- : undefined;
2532
- return message;
2533
- },
2534
- };
2535
- function createBaseData_EthLog() {
2536
- return { log: undefined, transaction: undefined };
2537
- }
2538
- exports.Data_EthLog = {
2539
- encode(message, writer = minimal_1.default.Writer.create()) {
2540
- if (message.log !== undefined) {
2541
- struct_1.Struct.encode(struct_1.Struct.wrap(message.log), writer.uint32(26).fork()).ldelim();
2542
- }
2543
- if (message.transaction !== undefined) {
2544
- writer.uint32(18).bytes(message.transaction);
2545
- }
2546
- return writer;
2547
- },
2548
- decode(input, length) {
2549
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2550
- let end = length === undefined ? reader.len : reader.pos + length;
2551
- const message = createBaseData_EthLog();
2552
- while (reader.pos < end) {
2553
- const tag = reader.uint32();
2554
- switch (tag >>> 3) {
2555
- case 3:
2556
- message.log = struct_1.Struct.unwrap(struct_1.Struct.decode(reader, reader.uint32()));
2557
- break;
2558
- case 2:
2559
- message.transaction = reader.bytes();
2560
- break;
2561
- default:
2562
- reader.skipType(tag & 7);
2563
- break;
2564
- }
2565
- }
2566
- return message;
2567
- },
2568
- fromJSON(object) {
2569
- return {
2570
- log: isObject(object.log) ? object.log : undefined,
2571
- transaction: isSet(object.transaction) ? bytesFromBase64(object.transaction) : undefined,
2572
- };
2573
- },
2574
- toJSON(message) {
2575
- const obj = {};
2576
- message.log !== undefined && (obj.log = message.log);
2577
- message.transaction !== undefined &&
2578
- (obj.transaction = message.transaction !== undefined ? base64FromBytes(message.transaction) : undefined);
2579
- return obj;
2580
- },
2581
- fromPartial(object) {
2582
- const message = createBaseData_EthLog();
2583
- message.log = object.log ?? undefined;
2584
- message.transaction = object.transaction ?? undefined;
2585
- return message;
2586
- },
2587
- };
2588
- function createBaseData_EthBlock() {
2589
- return { block: undefined };
2590
- }
2591
- exports.Data_EthBlock = {
2592
- encode(message, writer = minimal_1.default.Writer.create()) {
2593
- if (message.block !== undefined) {
2594
- struct_1.Struct.encode(struct_1.Struct.wrap(message.block), writer.uint32(18).fork()).ldelim();
2595
- }
2596
- return writer;
2597
- },
2598
- decode(input, length) {
2599
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2600
- let end = length === undefined ? reader.len : reader.pos + length;
2601
- const message = createBaseData_EthBlock();
2602
- while (reader.pos < end) {
2603
- const tag = reader.uint32();
2604
- switch (tag >>> 3) {
2605
- case 2:
2606
- message.block = struct_1.Struct.unwrap(struct_1.Struct.decode(reader, reader.uint32()));
2607
- break;
2608
- default:
2609
- reader.skipType(tag & 7);
2610
- break;
2611
- }
2612
- }
2613
- return message;
2614
- },
2615
- fromJSON(object) {
2616
- return { block: isObject(object.block) ? object.block : undefined };
2617
- },
2618
- toJSON(message) {
2619
- const obj = {};
2620
- message.block !== undefined && (obj.block = message.block);
2621
- return obj;
2622
- },
2623
- fromPartial(object) {
2624
- const message = createBaseData_EthBlock();
2625
- message.block = object.block ?? undefined;
2626
- return message;
2627
- },
2628
- };
2629
- function createBaseData_EthTransaction() {
2630
- return { transaction: undefined, transactionReceipt: undefined };
2631
- }
2632
- exports.Data_EthTransaction = {
2633
- encode(message, writer = minimal_1.default.Writer.create()) {
2634
- if (message.transaction !== undefined) {
2635
- struct_1.Struct.encode(struct_1.Struct.wrap(message.transaction), writer.uint32(34).fork()).ldelim();
2636
- }
2637
- if (message.transactionReceipt !== undefined) {
2638
- writer.uint32(26).bytes(message.transactionReceipt);
2639
- }
2640
- return writer;
2641
- },
2642
- decode(input, length) {
2643
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2644
- let end = length === undefined ? reader.len : reader.pos + length;
2645
- const message = createBaseData_EthTransaction();
2646
- while (reader.pos < end) {
2647
- const tag = reader.uint32();
2648
- switch (tag >>> 3) {
2649
- case 4:
2650
- message.transaction = struct_1.Struct.unwrap(struct_1.Struct.decode(reader, reader.uint32()));
2651
- break;
2652
- case 3:
2653
- message.transactionReceipt = reader.bytes();
2654
- break;
2655
- default:
2656
- reader.skipType(tag & 7);
2657
- break;
2658
- }
2659
- }
2660
- return message;
2661
- },
2662
- fromJSON(object) {
2663
- return {
2664
- transaction: isObject(object.transaction) ? object.transaction : undefined,
2665
- transactionReceipt: isSet(object.transactionReceipt) ? bytesFromBase64(object.transactionReceipt) : undefined,
2666
- };
2667
- },
2668
- toJSON(message) {
2669
- const obj = {};
2670
- message.transaction !== undefined && (obj.transaction = message.transaction);
2671
- message.transactionReceipt !== undefined && (obj.transactionReceipt = message.transactionReceipt !== undefined
2672
- ? base64FromBytes(message.transactionReceipt)
2673
- : undefined);
2674
- return obj;
2675
- },
2676
- fromPartial(object) {
2677
- const message = createBaseData_EthTransaction();
2678
- message.transaction = object.transaction ?? undefined;
2679
- message.transactionReceipt = object.transactionReceipt ?? undefined;
2680
- return message;
2681
- },
2682
- };
2683
- function createBaseData_EthTrace() {
2684
- return { trace: undefined, transaction: undefined, transactionReceipt: undefined };
2685
- }
2686
- exports.Data_EthTrace = {
2687
- encode(message, writer = minimal_1.default.Writer.create()) {
2688
- if (message.trace !== undefined) {
2689
- struct_1.Struct.encode(struct_1.Struct.wrap(message.trace), writer.uint32(34).fork()).ldelim();
2690
- }
2691
- if (message.transaction !== undefined) {
2692
- writer.uint32(18).bytes(message.transaction);
2693
- }
2694
- if (message.transactionReceipt !== undefined) {
2695
- writer.uint32(26).bytes(message.transactionReceipt);
2696
- }
2697
- return writer;
2698
- },
2699
- decode(input, length) {
2700
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2701
- let end = length === undefined ? reader.len : reader.pos + length;
2702
- const message = createBaseData_EthTrace();
2703
- while (reader.pos < end) {
2704
- const tag = reader.uint32();
2705
- switch (tag >>> 3) {
2706
- case 4:
2707
- message.trace = struct_1.Struct.unwrap(struct_1.Struct.decode(reader, reader.uint32()));
2708
- break;
2709
- case 2:
2710
- message.transaction = reader.bytes();
2711
- break;
2712
- case 3:
2713
- message.transactionReceipt = reader.bytes();
2714
- break;
2715
- default:
2716
- reader.skipType(tag & 7);
2717
- break;
2718
- }
2719
- }
2720
- return message;
2721
- },
2722
- fromJSON(object) {
2723
- return {
2724
- trace: isObject(object.trace) ? object.trace : undefined,
2725
- transaction: isSet(object.transaction) ? bytesFromBase64(object.transaction) : undefined,
2726
- transactionReceipt: isSet(object.transactionReceipt) ? bytesFromBase64(object.transactionReceipt) : undefined,
2727
- };
2728
- },
2729
- toJSON(message) {
2730
- const obj = {};
2731
- message.trace !== undefined && (obj.trace = message.trace);
2732
- message.transaction !== undefined &&
2733
- (obj.transaction = message.transaction !== undefined ? base64FromBytes(message.transaction) : undefined);
2734
- message.transactionReceipt !== undefined && (obj.transactionReceipt = message.transactionReceipt !== undefined
2735
- ? base64FromBytes(message.transactionReceipt)
2736
- : undefined);
2737
- return obj;
2738
- },
2739
- fromPartial(object) {
2740
- const message = createBaseData_EthTrace();
2741
- message.trace = object.trace ?? undefined;
2742
- message.transaction = object.transaction ?? undefined;
2743
- message.transactionReceipt = object.transactionReceipt ?? undefined;
2744
- return message;
2745
- },
2746
- };
2747
- function createBaseData_SolInstruction() {
2748
- return { instructionData: "", slot: long_1.default.UZERO, programAccountId: "", accounts: [], parsed: undefined };
2749
- }
2750
- exports.Data_SolInstruction = {
2751
- encode(message, writer = minimal_1.default.Writer.create()) {
2752
- if (message.instructionData !== "") {
2753
- writer.uint32(10).string(message.instructionData);
2754
- }
2755
- if (!message.slot.isZero()) {
2756
- writer.uint32(16).uint64(message.slot);
2757
- }
2758
- if (message.programAccountId !== "") {
2759
- writer.uint32(26).string(message.programAccountId);
2760
- }
2761
- for (const v of message.accounts) {
2762
- writer.uint32(42).string(v);
2763
- }
2764
- if (message.parsed !== undefined) {
2765
- struct_1.Struct.encode(struct_1.Struct.wrap(message.parsed), writer.uint32(34).fork()).ldelim();
2766
- }
2767
- return writer;
2768
- },
2769
- decode(input, length) {
2770
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2771
- let end = length === undefined ? reader.len : reader.pos + length;
2772
- const message = createBaseData_SolInstruction();
2773
- while (reader.pos < end) {
2774
- const tag = reader.uint32();
2775
- switch (tag >>> 3) {
2776
- case 1:
2777
- message.instructionData = reader.string();
2778
- break;
2779
- case 2:
2780
- message.slot = reader.uint64();
2781
- break;
2782
- case 3:
2783
- message.programAccountId = reader.string();
2784
- break;
2785
- case 5:
2786
- message.accounts.push(reader.string());
2787
- break;
2788
- case 4:
2789
- message.parsed = struct_1.Struct.unwrap(struct_1.Struct.decode(reader, reader.uint32()));
2790
- break;
2791
- default:
2792
- reader.skipType(tag & 7);
2793
- break;
2794
- }
2795
- }
2796
- return message;
2797
- },
2798
- fromJSON(object) {
2799
- return {
2800
- instructionData: isSet(object.instructionData) ? String(object.instructionData) : "",
2801
- slot: isSet(object.slot) ? long_1.default.fromValue(object.slot) : long_1.default.UZERO,
2802
- programAccountId: isSet(object.programAccountId) ? String(object.programAccountId) : "",
2803
- accounts: Array.isArray(object?.accounts) ? object.accounts.map((e) => String(e)) : [],
2804
- parsed: isObject(object.parsed) ? object.parsed : undefined,
2805
- };
2806
- },
2807
- toJSON(message) {
2808
- const obj = {};
2809
- message.instructionData !== undefined && (obj.instructionData = message.instructionData);
2810
- message.slot !== undefined && (obj.slot = (message.slot || long_1.default.UZERO).toString());
2811
- message.programAccountId !== undefined && (obj.programAccountId = message.programAccountId);
2812
- if (message.accounts) {
2813
- obj.accounts = message.accounts.map((e) => e);
2814
- }
2815
- else {
2816
- obj.accounts = [];
2817
- }
2818
- message.parsed !== undefined && (obj.parsed = message.parsed);
2819
- return obj;
2820
- },
2821
- fromPartial(object) {
2822
- const message = createBaseData_SolInstruction();
2823
- message.instructionData = object.instructionData ?? "";
2824
- message.slot = (object.slot !== undefined && object.slot !== null) ? long_1.default.fromValue(object.slot) : long_1.default.UZERO;
2825
- message.programAccountId = object.programAccountId ?? "";
2826
- message.accounts = object.accounts?.map((e) => e) || [];
2827
- message.parsed = object.parsed ?? undefined;
2828
- return message;
2829
- },
2830
- };
2831
- function createBaseData_AptEvent() {
2832
- return { event: undefined };
2833
- }
2834
- exports.Data_AptEvent = {
2835
- encode(message, writer = minimal_1.default.Writer.create()) {
2836
- if (message.event !== undefined) {
2837
- struct_1.Struct.encode(struct_1.Struct.wrap(message.event), writer.uint32(18).fork()).ldelim();
2838
- }
2839
- return writer;
2840
- },
2841
- decode(input, length) {
2842
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2843
- let end = length === undefined ? reader.len : reader.pos + length;
2844
- const message = createBaseData_AptEvent();
2845
- while (reader.pos < end) {
2846
- const tag = reader.uint32();
2847
- switch (tag >>> 3) {
2848
- case 2:
2849
- message.event = struct_1.Struct.unwrap(struct_1.Struct.decode(reader, reader.uint32()));
2850
- break;
2851
- default:
2852
- reader.skipType(tag & 7);
2853
- break;
2854
- }
2855
- }
2856
- return message;
2857
- },
2858
- fromJSON(object) {
2859
- return { event: isObject(object.event) ? object.event : undefined };
2860
- },
2861
- toJSON(message) {
2862
- const obj = {};
2863
- message.event !== undefined && (obj.event = message.event);
2864
- return obj;
2865
- },
2866
- fromPartial(object) {
2867
- const message = createBaseData_AptEvent();
2868
- message.event = object.event ?? undefined;
2869
- return message;
2870
- },
2871
- };
2872
- function createBaseData_AptCall() {
2873
- return { call: undefined };
2874
- }
2875
- exports.Data_AptCall = {
2876
- encode(message, writer = minimal_1.default.Writer.create()) {
2877
- if (message.call !== undefined) {
2878
- struct_1.Struct.encode(struct_1.Struct.wrap(message.call), writer.uint32(18).fork()).ldelim();
2879
- }
2880
- return writer;
2881
- },
2882
- decode(input, length) {
2883
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2884
- let end = length === undefined ? reader.len : reader.pos + length;
2885
- const message = createBaseData_AptCall();
2886
- while (reader.pos < end) {
2887
- const tag = reader.uint32();
2888
- switch (tag >>> 3) {
2889
- case 2:
2890
- message.call = struct_1.Struct.unwrap(struct_1.Struct.decode(reader, reader.uint32()));
2891
- break;
2892
- default:
2893
- reader.skipType(tag & 7);
2894
- break;
2895
- }
2896
- }
2897
- return message;
2898
- },
2899
- fromJSON(object) {
2900
- return { call: isObject(object.call) ? object.call : undefined };
2901
- },
2902
- toJSON(message) {
2903
- const obj = {};
2904
- message.call !== undefined && (obj.call = message.call);
2905
- return obj;
2906
- },
2907
- fromPartial(object) {
2908
- const message = createBaseData_AptCall();
2909
- message.call = object.call ?? undefined;
2910
- return message;
2911
- },
2912
- };
2913
- function createBaseData_AptResource() {
2914
- return { resources: [], version: long_1.default.ZERO, timestampMicros: long_1.default.ZERO };
2915
- }
2916
- exports.Data_AptResource = {
2917
- encode(message, writer = minimal_1.default.Writer.create()) {
2918
- for (const v of message.resources) {
2919
- struct_1.Struct.encode(struct_1.Struct.wrap(v), writer.uint32(34).fork()).ldelim();
2920
- }
2921
- if (!message.version.isZero()) {
2922
- writer.uint32(16).int64(message.version);
2923
- }
2924
- if (!message.timestampMicros.isZero()) {
2925
- writer.uint32(40).int64(message.timestampMicros);
2926
- }
2927
- return writer;
2928
- },
2929
- decode(input, length) {
2930
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
2931
- let end = length === undefined ? reader.len : reader.pos + length;
2932
- const message = createBaseData_AptResource();
2933
- while (reader.pos < end) {
2934
- const tag = reader.uint32();
2935
- switch (tag >>> 3) {
2936
- case 4:
2937
- message.resources.push(struct_1.Struct.unwrap(struct_1.Struct.decode(reader, reader.uint32())));
2938
- break;
2939
- case 2:
2940
- message.version = reader.int64();
2941
- break;
2942
- case 5:
2943
- message.timestampMicros = reader.int64();
2944
- break;
2945
- default:
2946
- reader.skipType(tag & 7);
2947
- break;
2948
- }
2949
- }
2950
- return message;
2951
- },
2952
- fromJSON(object) {
2953
- return {
2954
- resources: Array.isArray(object?.resources) ? [...object.resources] : [],
2955
- version: isSet(object.version) ? long_1.default.fromValue(object.version) : long_1.default.ZERO,
2956
- timestampMicros: isSet(object.timestampMicros) ? long_1.default.fromValue(object.timestampMicros) : long_1.default.ZERO,
2957
- };
2958
- },
2959
- toJSON(message) {
2960
- const obj = {};
2961
- if (message.resources) {
2962
- obj.resources = message.resources.map((e) => e);
2963
- }
2964
- else {
2965
- obj.resources = [];
2966
- }
2967
- message.version !== undefined && (obj.version = (message.version || long_1.default.ZERO).toString());
2968
- message.timestampMicros !== undefined && (obj.timestampMicros = (message.timestampMicros || long_1.default.ZERO).toString());
2969
- return obj;
2970
- },
2971
- fromPartial(object) {
2972
- const message = createBaseData_AptResource();
2973
- message.resources = object.resources?.map((e) => e) || [];
2974
- message.version = (object.version !== undefined && object.version !== null)
2975
- ? long_1.default.fromValue(object.version)
2976
- : long_1.default.ZERO;
2977
- message.timestampMicros = (object.timestampMicros !== undefined && object.timestampMicros !== null)
2978
- ? long_1.default.fromValue(object.timestampMicros)
2979
- : long_1.default.ZERO;
2980
- return message;
2981
- },
2982
- };
2983
- function createBaseDataBinding() {
2984
- return { data: undefined, handlerType: 0, handlerIds: [] };
2985
- }
2986
- exports.DataBinding = {
2987
- encode(message, writer = minimal_1.default.Writer.create()) {
2988
- if (message.data !== undefined) {
2989
- exports.Data.encode(message.data, writer.uint32(10).fork()).ldelim();
2990
- }
2991
- if (message.handlerType !== 0) {
2992
- writer.uint32(24).int32(message.handlerType);
2993
- }
2994
- writer.uint32(34).fork();
2995
- for (const v of message.handlerIds) {
2996
- writer.int32(v);
2997
- }
2998
- writer.ldelim();
2999
- return writer;
3000
- },
3001
- decode(input, length) {
3002
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3003
- let end = length === undefined ? reader.len : reader.pos + length;
3004
- const message = createBaseDataBinding();
3005
- while (reader.pos < end) {
3006
- const tag = reader.uint32();
3007
- switch (tag >>> 3) {
3008
- case 1:
3009
- message.data = exports.Data.decode(reader, reader.uint32());
3010
- break;
3011
- case 3:
3012
- message.handlerType = reader.int32();
3013
- break;
3014
- case 4:
3015
- if ((tag & 7) === 2) {
3016
- const end2 = reader.uint32() + reader.pos;
3017
- while (reader.pos < end2) {
3018
- message.handlerIds.push(reader.int32());
3019
- }
3020
- }
3021
- else {
3022
- message.handlerIds.push(reader.int32());
3023
- }
3024
- break;
3025
- default:
3026
- reader.skipType(tag & 7);
3027
- break;
3028
- }
3029
- }
3030
- return message;
3031
- },
3032
- fromJSON(object) {
3033
- return {
3034
- data: isSet(object.data) ? exports.Data.fromJSON(object.data) : undefined,
3035
- handlerType: isSet(object.handlerType) ? handlerTypeFromJSON(object.handlerType) : 0,
3036
- handlerIds: Array.isArray(object?.handlerIds) ? object.handlerIds.map((e) => Number(e)) : [],
3037
- };
3038
- },
3039
- toJSON(message) {
3040
- const obj = {};
3041
- message.data !== undefined && (obj.data = message.data ? exports.Data.toJSON(message.data) : undefined);
3042
- message.handlerType !== undefined && (obj.handlerType = handlerTypeToJSON(message.handlerType));
3043
- if (message.handlerIds) {
3044
- obj.handlerIds = message.handlerIds.map((e) => Math.round(e));
3045
- }
3046
- else {
3047
- obj.handlerIds = [];
3048
- }
3049
- return obj;
3050
- },
3051
- fromPartial(object) {
3052
- const message = createBaseDataBinding();
3053
- message.data = (object.data !== undefined && object.data !== null) ? exports.Data.fromPartial(object.data) : undefined;
3054
- message.handlerType = object.handlerType ?? 0;
3055
- message.handlerIds = object.handlerIds?.map((e) => e) || [];
3056
- return message;
3057
- },
3058
- };
3059
- function createBaseProcessResult() {
3060
- return { gauges: [], counters: [], logs: [], events: [], exports: [] };
3061
- }
3062
- exports.ProcessResult = {
3063
- encode(message, writer = minimal_1.default.Writer.create()) {
3064
- for (const v of message.gauges) {
3065
- exports.GaugeResult.encode(v, writer.uint32(10).fork()).ldelim();
3066
- }
3067
- for (const v of message.counters) {
3068
- exports.CounterResult.encode(v, writer.uint32(18).fork()).ldelim();
3069
- }
3070
- for (const v of message.logs) {
3071
- exports.LogResult.encode(v, writer.uint32(26).fork()).ldelim();
3072
- }
3073
- for (const v of message.events) {
3074
- exports.EventTrackingResult.encode(v, writer.uint32(34).fork()).ldelim();
3075
- }
3076
- for (const v of message.exports) {
3077
- exports.ExportResult.encode(v, writer.uint32(42).fork()).ldelim();
3078
- }
3079
- return writer;
3080
- },
3081
- decode(input, length) {
3082
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3083
- let end = length === undefined ? reader.len : reader.pos + length;
3084
- const message = createBaseProcessResult();
3085
- while (reader.pos < end) {
3086
- const tag = reader.uint32();
3087
- switch (tag >>> 3) {
3088
- case 1:
3089
- message.gauges.push(exports.GaugeResult.decode(reader, reader.uint32()));
3090
- break;
3091
- case 2:
3092
- message.counters.push(exports.CounterResult.decode(reader, reader.uint32()));
3093
- break;
3094
- case 3:
3095
- message.logs.push(exports.LogResult.decode(reader, reader.uint32()));
3096
- break;
3097
- case 4:
3098
- message.events.push(exports.EventTrackingResult.decode(reader, reader.uint32()));
3099
- break;
3100
- case 5:
3101
- message.exports.push(exports.ExportResult.decode(reader, reader.uint32()));
3102
- break;
3103
- default:
3104
- reader.skipType(tag & 7);
3105
- break;
3106
- }
3107
- }
3108
- return message;
3109
- },
3110
- fromJSON(object) {
3111
- return {
3112
- gauges: Array.isArray(object?.gauges) ? object.gauges.map((e) => exports.GaugeResult.fromJSON(e)) : [],
3113
- counters: Array.isArray(object?.counters) ? object.counters.map((e) => exports.CounterResult.fromJSON(e)) : [],
3114
- logs: Array.isArray(object?.logs) ? object.logs.map((e) => exports.LogResult.fromJSON(e)) : [],
3115
- events: Array.isArray(object?.events) ? object.events.map((e) => exports.EventTrackingResult.fromJSON(e)) : [],
3116
- exports: Array.isArray(object?.exports) ? object.exports.map((e) => exports.ExportResult.fromJSON(e)) : [],
3117
- };
3118
- },
3119
- toJSON(message) {
3120
- const obj = {};
3121
- if (message.gauges) {
3122
- obj.gauges = message.gauges.map((e) => e ? exports.GaugeResult.toJSON(e) : undefined);
3123
- }
3124
- else {
3125
- obj.gauges = [];
3126
- }
3127
- if (message.counters) {
3128
- obj.counters = message.counters.map((e) => e ? exports.CounterResult.toJSON(e) : undefined);
3129
- }
3130
- else {
3131
- obj.counters = [];
3132
- }
3133
- if (message.logs) {
3134
- obj.logs = message.logs.map((e) => e ? exports.LogResult.toJSON(e) : undefined);
3135
- }
3136
- else {
3137
- obj.logs = [];
3138
- }
3139
- if (message.events) {
3140
- obj.events = message.events.map((e) => e ? exports.EventTrackingResult.toJSON(e) : undefined);
3141
- }
3142
- else {
3143
- obj.events = [];
3144
- }
3145
- if (message.exports) {
3146
- obj.exports = message.exports.map((e) => e ? exports.ExportResult.toJSON(e) : undefined);
3147
- }
3148
- else {
3149
- obj.exports = [];
3150
- }
3151
- return obj;
3152
- },
3153
- fromPartial(object) {
3154
- const message = createBaseProcessResult();
3155
- message.gauges = object.gauges?.map((e) => exports.GaugeResult.fromPartial(e)) || [];
3156
- message.counters = object.counters?.map((e) => exports.CounterResult.fromPartial(e)) || [];
3157
- message.logs = object.logs?.map((e) => exports.LogResult.fromPartial(e)) || [];
3158
- message.events = object.events?.map((e) => exports.EventTrackingResult.fromPartial(e)) || [];
3159
- message.exports = object.exports?.map((e) => exports.ExportResult.fromPartial(e)) || [];
3160
- return message;
3161
- },
3162
- };
3163
- function createBaseRecordMetaData() {
3164
- return {
3165
- address: "",
3166
- contractName: "",
3167
- blockNumber: long_1.default.UZERO,
3168
- transactionHash: "",
3169
- chainId: "",
3170
- transactionIndex: 0,
3171
- logIndex: 0,
3172
- name: "",
3173
- labels: {},
3174
- };
3175
- }
3176
- exports.RecordMetaData = {
3177
- encode(message, writer = minimal_1.default.Writer.create()) {
3178
- if (message.address !== "") {
3179
- writer.uint32(10).string(message.address);
3180
- }
3181
- if (message.contractName !== "") {
3182
- writer.uint32(74).string(message.contractName);
3183
- }
3184
- if (!message.blockNumber.isZero()) {
3185
- writer.uint32(16).uint64(message.blockNumber);
3186
- }
3187
- if (message.transactionHash !== "") {
3188
- writer.uint32(50).string(message.transactionHash);
3189
- }
3190
- if (message.chainId !== "") {
3191
- writer.uint32(42).string(message.chainId);
3192
- }
3193
- if (message.transactionIndex !== 0) {
3194
- writer.uint32(24).int32(message.transactionIndex);
3195
- }
3196
- if (message.logIndex !== 0) {
3197
- writer.uint32(32).int32(message.logIndex);
3198
- }
3199
- if (message.name !== "") {
3200
- writer.uint32(82).string(message.name);
3201
- }
3202
- Object.entries(message.labels).forEach(([key, value]) => {
3203
- exports.RecordMetaData_LabelsEntry.encode({ key: key, value }, writer.uint32(58).fork()).ldelim();
3204
- });
3205
- return writer;
3206
- },
3207
- decode(input, length) {
3208
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3209
- let end = length === undefined ? reader.len : reader.pos + length;
3210
- const message = createBaseRecordMetaData();
3211
- while (reader.pos < end) {
3212
- const tag = reader.uint32();
3213
- switch (tag >>> 3) {
3214
- case 1:
3215
- message.address = reader.string();
3216
- break;
3217
- case 9:
3218
- message.contractName = reader.string();
3219
- break;
3220
- case 2:
3221
- message.blockNumber = reader.uint64();
3222
- break;
3223
- case 6:
3224
- message.transactionHash = reader.string();
3225
- break;
3226
- case 5:
3227
- message.chainId = reader.string();
3228
- break;
3229
- case 3:
3230
- message.transactionIndex = reader.int32();
3231
- break;
3232
- case 4:
3233
- message.logIndex = reader.int32();
3234
- break;
3235
- case 10:
3236
- message.name = reader.string();
3237
- break;
3238
- case 7:
3239
- const entry7 = exports.RecordMetaData_LabelsEntry.decode(reader, reader.uint32());
3240
- if (entry7.value !== undefined) {
3241
- message.labels[entry7.key] = entry7.value;
3242
- }
3243
- break;
3244
- default:
3245
- reader.skipType(tag & 7);
3246
- break;
3247
- }
3248
- }
3249
- return message;
3250
- },
3251
- fromJSON(object) {
3252
- return {
3253
- address: isSet(object.address) ? String(object.address) : "",
3254
- contractName: isSet(object.contractName) ? String(object.contractName) : "",
3255
- blockNumber: isSet(object.blockNumber) ? long_1.default.fromValue(object.blockNumber) : long_1.default.UZERO,
3256
- transactionHash: isSet(object.transactionHash) ? String(object.transactionHash) : "",
3257
- chainId: isSet(object.chainId) ? String(object.chainId) : "",
3258
- transactionIndex: isSet(object.transactionIndex) ? Number(object.transactionIndex) : 0,
3259
- logIndex: isSet(object.logIndex) ? Number(object.logIndex) : 0,
3260
- name: isSet(object.name) ? String(object.name) : "",
3261
- labels: isObject(object.labels)
3262
- ? Object.entries(object.labels).reduce((acc, [key, value]) => {
3263
- acc[key] = String(value);
3264
- return acc;
3265
- }, {})
3266
- : {},
3267
- };
3268
- },
3269
- toJSON(message) {
3270
- const obj = {};
3271
- message.address !== undefined && (obj.address = message.address);
3272
- message.contractName !== undefined && (obj.contractName = message.contractName);
3273
- message.blockNumber !== undefined && (obj.blockNumber = (message.blockNumber || long_1.default.UZERO).toString());
3274
- message.transactionHash !== undefined && (obj.transactionHash = message.transactionHash);
3275
- message.chainId !== undefined && (obj.chainId = message.chainId);
3276
- message.transactionIndex !== undefined && (obj.transactionIndex = Math.round(message.transactionIndex));
3277
- message.logIndex !== undefined && (obj.logIndex = Math.round(message.logIndex));
3278
- message.name !== undefined && (obj.name = message.name);
3279
- obj.labels = {};
3280
- if (message.labels) {
3281
- Object.entries(message.labels).forEach(([k, v]) => {
3282
- obj.labels[k] = v;
3283
- });
3284
- }
3285
- return obj;
3286
- },
3287
- fromPartial(object) {
3288
- const message = createBaseRecordMetaData();
3289
- message.address = object.address ?? "";
3290
- message.contractName = object.contractName ?? "";
3291
- message.blockNumber = (object.blockNumber !== undefined && object.blockNumber !== null)
3292
- ? long_1.default.fromValue(object.blockNumber)
3293
- : long_1.default.UZERO;
3294
- message.transactionHash = object.transactionHash ?? "";
3295
- message.chainId = object.chainId ?? "";
3296
- message.transactionIndex = object.transactionIndex ?? 0;
3297
- message.logIndex = object.logIndex ?? 0;
3298
- message.name = object.name ?? "";
3299
- message.labels = Object.entries(object.labels ?? {}).reduce((acc, [key, value]) => {
3300
- if (value !== undefined) {
3301
- acc[key] = String(value);
3302
- }
3303
- return acc;
3304
- }, {});
3305
- return message;
3306
- },
3307
- };
3308
- function createBaseRecordMetaData_LabelsEntry() {
3309
- return { key: "", value: "" };
3310
- }
3311
- exports.RecordMetaData_LabelsEntry = {
3312
- encode(message, writer = minimal_1.default.Writer.create()) {
3313
- if (message.key !== "") {
3314
- writer.uint32(10).string(message.key);
3315
- }
3316
- if (message.value !== "") {
3317
- writer.uint32(18).string(message.value);
3318
- }
3319
- return writer;
3320
- },
3321
- decode(input, length) {
3322
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3323
- let end = length === undefined ? reader.len : reader.pos + length;
3324
- const message = createBaseRecordMetaData_LabelsEntry();
3325
- while (reader.pos < end) {
3326
- const tag = reader.uint32();
3327
- switch (tag >>> 3) {
3328
- case 1:
3329
- message.key = reader.string();
3330
- break;
3331
- case 2:
3332
- message.value = reader.string();
3333
- break;
3334
- default:
3335
- reader.skipType(tag & 7);
3336
- break;
3337
- }
3338
- }
3339
- return message;
3340
- },
3341
- fromJSON(object) {
3342
- return { key: isSet(object.key) ? String(object.key) : "", value: isSet(object.value) ? String(object.value) : "" };
3343
- },
3344
- toJSON(message) {
3345
- const obj = {};
3346
- message.key !== undefined && (obj.key = message.key);
3347
- message.value !== undefined && (obj.value = message.value);
3348
- return obj;
3349
- },
3350
- fromPartial(object) {
3351
- const message = createBaseRecordMetaData_LabelsEntry();
3352
- message.key = object.key ?? "";
3353
- message.value = object.value ?? "";
3354
- return message;
3355
- },
3356
- };
3357
- function createBaseMetricValue() {
3358
- return { bigDecimal: undefined, doubleValue: undefined, bigInteger: undefined };
3359
- }
3360
- exports.MetricValue = {
3361
- encode(message, writer = minimal_1.default.Writer.create()) {
3362
- if (message.bigDecimal !== undefined) {
3363
- writer.uint32(10).string(message.bigDecimal);
3364
- }
3365
- if (message.doubleValue !== undefined) {
3366
- writer.uint32(17).double(message.doubleValue);
3367
- }
3368
- if (message.bigInteger !== undefined) {
3369
- exports.BigInteger.encode(message.bigInteger, writer.uint32(26).fork()).ldelim();
3370
- }
3371
- return writer;
3372
- },
3373
- decode(input, length) {
3374
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3375
- let end = length === undefined ? reader.len : reader.pos + length;
3376
- const message = createBaseMetricValue();
3377
- while (reader.pos < end) {
3378
- const tag = reader.uint32();
3379
- switch (tag >>> 3) {
3380
- case 1:
3381
- message.bigDecimal = reader.string();
3382
- break;
3383
- case 2:
3384
- message.doubleValue = reader.double();
3385
- break;
3386
- case 3:
3387
- message.bigInteger = exports.BigInteger.decode(reader, reader.uint32());
3388
- break;
3389
- default:
3390
- reader.skipType(tag & 7);
3391
- break;
3392
- }
3393
- }
3394
- return message;
3395
- },
3396
- fromJSON(object) {
3397
- return {
3398
- bigDecimal: isSet(object.bigDecimal) ? String(object.bigDecimal) : undefined,
3399
- doubleValue: isSet(object.doubleValue) ? Number(object.doubleValue) : undefined,
3400
- bigInteger: isSet(object.bigInteger) ? exports.BigInteger.fromJSON(object.bigInteger) : undefined,
3401
- };
3402
- },
3403
- toJSON(message) {
3404
- const obj = {};
3405
- message.bigDecimal !== undefined && (obj.bigDecimal = message.bigDecimal);
3406
- message.doubleValue !== undefined && (obj.doubleValue = message.doubleValue);
3407
- message.bigInteger !== undefined &&
3408
- (obj.bigInteger = message.bigInteger ? exports.BigInteger.toJSON(message.bigInteger) : undefined);
3409
- return obj;
3410
- },
3411
- fromPartial(object) {
3412
- const message = createBaseMetricValue();
3413
- message.bigDecimal = object.bigDecimal ?? undefined;
3414
- message.doubleValue = object.doubleValue ?? undefined;
3415
- message.bigInteger = (object.bigInteger !== undefined && object.bigInteger !== null)
3416
- ? exports.BigInteger.fromPartial(object.bigInteger)
3417
- : undefined;
3418
- return message;
3419
- },
3420
- };
3421
- function createBaseBigInteger() {
3422
- return { negative: false, data: new Uint8Array() };
3423
- }
3424
- exports.BigInteger = {
3425
- encode(message, writer = minimal_1.default.Writer.create()) {
3426
- if (message.negative === true) {
3427
- writer.uint32(8).bool(message.negative);
3428
- }
3429
- if (message.data.length !== 0) {
3430
- writer.uint32(18).bytes(message.data);
3431
- }
3432
- return writer;
3433
- },
3434
- decode(input, length) {
3435
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3436
- let end = length === undefined ? reader.len : reader.pos + length;
3437
- const message = createBaseBigInteger();
3438
- while (reader.pos < end) {
3439
- const tag = reader.uint32();
3440
- switch (tag >>> 3) {
3441
- case 1:
3442
- message.negative = reader.bool();
3443
- break;
3444
- case 2:
3445
- message.data = reader.bytes();
3446
- break;
3447
- default:
3448
- reader.skipType(tag & 7);
3449
- break;
3450
- }
3451
- }
3452
- return message;
3453
- },
3454
- fromJSON(object) {
3455
- return {
3456
- negative: isSet(object.negative) ? Boolean(object.negative) : false,
3457
- data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
3458
- };
3459
- },
3460
- toJSON(message) {
3461
- const obj = {};
3462
- message.negative !== undefined && (obj.negative = message.negative);
3463
- message.data !== undefined &&
3464
- (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
3465
- return obj;
3466
- },
3467
- fromPartial(object) {
3468
- const message = createBaseBigInteger();
3469
- message.negative = object.negative ?? false;
3470
- message.data = object.data ?? new Uint8Array();
3471
- return message;
3472
- },
3473
- };
3474
- function createBaseRuntimeInfo() {
3475
- return { from: 0 };
3476
- }
3477
- exports.RuntimeInfo = {
3478
- encode(message, writer = minimal_1.default.Writer.create()) {
3479
- if (message.from !== 0) {
3480
- writer.uint32(8).int32(message.from);
3481
- }
3482
- return writer;
3483
- },
3484
- decode(input, length) {
3485
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3486
- let end = length === undefined ? reader.len : reader.pos + length;
3487
- const message = createBaseRuntimeInfo();
3488
- while (reader.pos < end) {
3489
- const tag = reader.uint32();
3490
- switch (tag >>> 3) {
3491
- case 1:
3492
- message.from = reader.int32();
3493
- break;
3494
- default:
3495
- reader.skipType(tag & 7);
3496
- break;
3497
- }
3498
- }
3499
- return message;
3500
- },
3501
- fromJSON(object) {
3502
- return { from: isSet(object.from) ? handlerTypeFromJSON(object.from) : 0 };
3503
- },
3504
- toJSON(message) {
3505
- const obj = {};
3506
- message.from !== undefined && (obj.from = handlerTypeToJSON(message.from));
3507
- return obj;
3508
- },
3509
- fromPartial(object) {
3510
- const message = createBaseRuntimeInfo();
3511
- message.from = object.from ?? 0;
3512
- return message;
3513
- },
3514
- };
3515
- function createBaseGaugeResult() {
3516
- return { metadata: undefined, metricValue: undefined, runtimeInfo: undefined };
3517
- }
3518
- exports.GaugeResult = {
3519
- encode(message, writer = minimal_1.default.Writer.create()) {
3520
- if (message.metadata !== undefined) {
3521
- exports.RecordMetaData.encode(message.metadata, writer.uint32(10).fork()).ldelim();
3522
- }
3523
- if (message.metricValue !== undefined) {
3524
- exports.MetricValue.encode(message.metricValue, writer.uint32(18).fork()).ldelim();
3525
- }
3526
- if (message.runtimeInfo !== undefined) {
3527
- exports.RuntimeInfo.encode(message.runtimeInfo, writer.uint32(26).fork()).ldelim();
3528
- }
3529
- return writer;
3530
- },
3531
- decode(input, length) {
3532
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3533
- let end = length === undefined ? reader.len : reader.pos + length;
3534
- const message = createBaseGaugeResult();
3535
- while (reader.pos < end) {
3536
- const tag = reader.uint32();
3537
- switch (tag >>> 3) {
3538
- case 1:
3539
- message.metadata = exports.RecordMetaData.decode(reader, reader.uint32());
3540
- break;
3541
- case 2:
3542
- message.metricValue = exports.MetricValue.decode(reader, reader.uint32());
3543
- break;
3544
- case 3:
3545
- message.runtimeInfo = exports.RuntimeInfo.decode(reader, reader.uint32());
3546
- break;
3547
- default:
3548
- reader.skipType(tag & 7);
3549
- break;
3550
- }
3551
- }
3552
- return message;
3553
- },
3554
- fromJSON(object) {
3555
- return {
3556
- metadata: isSet(object.metadata) ? exports.RecordMetaData.fromJSON(object.metadata) : undefined,
3557
- metricValue: isSet(object.metricValue) ? exports.MetricValue.fromJSON(object.metricValue) : undefined,
3558
- runtimeInfo: isSet(object.runtimeInfo) ? exports.RuntimeInfo.fromJSON(object.runtimeInfo) : undefined,
3559
- };
3560
- },
3561
- toJSON(message) {
3562
- const obj = {};
3563
- message.metadata !== undefined &&
3564
- (obj.metadata = message.metadata ? exports.RecordMetaData.toJSON(message.metadata) : undefined);
3565
- message.metricValue !== undefined &&
3566
- (obj.metricValue = message.metricValue ? exports.MetricValue.toJSON(message.metricValue) : undefined);
3567
- message.runtimeInfo !== undefined &&
3568
- (obj.runtimeInfo = message.runtimeInfo ? exports.RuntimeInfo.toJSON(message.runtimeInfo) : undefined);
3569
- return obj;
3570
- },
3571
- fromPartial(object) {
3572
- const message = createBaseGaugeResult();
3573
- message.metadata = (object.metadata !== undefined && object.metadata !== null)
3574
- ? exports.RecordMetaData.fromPartial(object.metadata)
3575
- : undefined;
3576
- message.metricValue = (object.metricValue !== undefined && object.metricValue !== null)
3577
- ? exports.MetricValue.fromPartial(object.metricValue)
3578
- : undefined;
3579
- message.runtimeInfo = (object.runtimeInfo !== undefined && object.runtimeInfo !== null)
3580
- ? exports.RuntimeInfo.fromPartial(object.runtimeInfo)
3581
- : undefined;
3582
- return message;
3583
- },
3584
- };
3585
- function createBaseCounterResult() {
3586
- return { metadata: undefined, metricValue: undefined, add: false, runtimeInfo: undefined };
3587
- }
3588
- exports.CounterResult = {
3589
- encode(message, writer = minimal_1.default.Writer.create()) {
3590
- if (message.metadata !== undefined) {
3591
- exports.RecordMetaData.encode(message.metadata, writer.uint32(10).fork()).ldelim();
3592
- }
3593
- if (message.metricValue !== undefined) {
3594
- exports.MetricValue.encode(message.metricValue, writer.uint32(18).fork()).ldelim();
3595
- }
3596
- if (message.add === true) {
3597
- writer.uint32(24).bool(message.add);
3598
- }
3599
- if (message.runtimeInfo !== undefined) {
3600
- exports.RuntimeInfo.encode(message.runtimeInfo, writer.uint32(34).fork()).ldelim();
3601
- }
3602
- return writer;
3603
- },
3604
- decode(input, length) {
3605
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3606
- let end = length === undefined ? reader.len : reader.pos + length;
3607
- const message = createBaseCounterResult();
3608
- while (reader.pos < end) {
3609
- const tag = reader.uint32();
3610
- switch (tag >>> 3) {
3611
- case 1:
3612
- message.metadata = exports.RecordMetaData.decode(reader, reader.uint32());
3613
- break;
3614
- case 2:
3615
- message.metricValue = exports.MetricValue.decode(reader, reader.uint32());
3616
- break;
3617
- case 3:
3618
- message.add = reader.bool();
3619
- break;
3620
- case 4:
3621
- message.runtimeInfo = exports.RuntimeInfo.decode(reader, reader.uint32());
3622
- break;
3623
- default:
3624
- reader.skipType(tag & 7);
3625
- break;
3626
- }
3627
- }
3628
- return message;
3629
- },
3630
- fromJSON(object) {
3631
- return {
3632
- metadata: isSet(object.metadata) ? exports.RecordMetaData.fromJSON(object.metadata) : undefined,
3633
- metricValue: isSet(object.metricValue) ? exports.MetricValue.fromJSON(object.metricValue) : undefined,
3634
- add: isSet(object.add) ? Boolean(object.add) : false,
3635
- runtimeInfo: isSet(object.runtimeInfo) ? exports.RuntimeInfo.fromJSON(object.runtimeInfo) : undefined,
3636
- };
3637
- },
3638
- toJSON(message) {
3639
- const obj = {};
3640
- message.metadata !== undefined &&
3641
- (obj.metadata = message.metadata ? exports.RecordMetaData.toJSON(message.metadata) : undefined);
3642
- message.metricValue !== undefined &&
3643
- (obj.metricValue = message.metricValue ? exports.MetricValue.toJSON(message.metricValue) : undefined);
3644
- message.add !== undefined && (obj.add = message.add);
3645
- message.runtimeInfo !== undefined &&
3646
- (obj.runtimeInfo = message.runtimeInfo ? exports.RuntimeInfo.toJSON(message.runtimeInfo) : undefined);
3647
- return obj;
3648
- },
3649
- fromPartial(object) {
3650
- const message = createBaseCounterResult();
3651
- message.metadata = (object.metadata !== undefined && object.metadata !== null)
3652
- ? exports.RecordMetaData.fromPartial(object.metadata)
3653
- : undefined;
3654
- message.metricValue = (object.metricValue !== undefined && object.metricValue !== null)
3655
- ? exports.MetricValue.fromPartial(object.metricValue)
3656
- : undefined;
3657
- message.add = object.add ?? false;
3658
- message.runtimeInfo = (object.runtimeInfo !== undefined && object.runtimeInfo !== null)
3659
- ? exports.RuntimeInfo.fromPartial(object.runtimeInfo)
3660
- : undefined;
3661
- return message;
3662
- },
3663
- };
3664
- function createBaseLogResult() {
3665
- return { metadata: undefined, level: 0, message: "", attributes: "", runtimeInfo: undefined };
3666
- }
3667
- exports.LogResult = {
3668
- encode(message, writer = minimal_1.default.Writer.create()) {
3669
- if (message.metadata !== undefined) {
3670
- exports.RecordMetaData.encode(message.metadata, writer.uint32(10).fork()).ldelim();
3671
- }
3672
- if (message.level !== 0) {
3673
- writer.uint32(16).int32(message.level);
3674
- }
3675
- if (message.message !== "") {
3676
- writer.uint32(26).string(message.message);
3677
- }
3678
- if (message.attributes !== "") {
3679
- writer.uint32(50).string(message.attributes);
3680
- }
3681
- if (message.runtimeInfo !== undefined) {
3682
- exports.RuntimeInfo.encode(message.runtimeInfo, writer.uint32(34).fork()).ldelim();
3683
- }
3684
- return writer;
3685
- },
3686
- decode(input, length) {
3687
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3688
- let end = length === undefined ? reader.len : reader.pos + length;
3689
- const message = createBaseLogResult();
3690
- while (reader.pos < end) {
3691
- const tag = reader.uint32();
3692
- switch (tag >>> 3) {
3693
- case 1:
3694
- message.metadata = exports.RecordMetaData.decode(reader, reader.uint32());
3695
- break;
3696
- case 2:
3697
- message.level = reader.int32();
3698
- break;
3699
- case 3:
3700
- message.message = reader.string();
3701
- break;
3702
- case 6:
3703
- message.attributes = reader.string();
3704
- break;
3705
- case 4:
3706
- message.runtimeInfo = exports.RuntimeInfo.decode(reader, reader.uint32());
3707
- break;
3708
- default:
3709
- reader.skipType(tag & 7);
3710
- break;
3711
- }
3712
- }
3713
- return message;
3714
- },
3715
- fromJSON(object) {
3716
- return {
3717
- metadata: isSet(object.metadata) ? exports.RecordMetaData.fromJSON(object.metadata) : undefined,
3718
- level: isSet(object.level) ? logLevelFromJSON(object.level) : 0,
3719
- message: isSet(object.message) ? String(object.message) : "",
3720
- attributes: isSet(object.attributes) ? String(object.attributes) : "",
3721
- runtimeInfo: isSet(object.runtimeInfo) ? exports.RuntimeInfo.fromJSON(object.runtimeInfo) : undefined,
3722
- };
3723
- },
3724
- toJSON(message) {
3725
- const obj = {};
3726
- message.metadata !== undefined &&
3727
- (obj.metadata = message.metadata ? exports.RecordMetaData.toJSON(message.metadata) : undefined);
3728
- message.level !== undefined && (obj.level = logLevelToJSON(message.level));
3729
- message.message !== undefined && (obj.message = message.message);
3730
- message.attributes !== undefined && (obj.attributes = message.attributes);
3731
- message.runtimeInfo !== undefined &&
3732
- (obj.runtimeInfo = message.runtimeInfo ? exports.RuntimeInfo.toJSON(message.runtimeInfo) : undefined);
3733
- return obj;
3734
- },
3735
- fromPartial(object) {
3736
- const message = createBaseLogResult();
3737
- message.metadata = (object.metadata !== undefined && object.metadata !== null)
3738
- ? exports.RecordMetaData.fromPartial(object.metadata)
3739
- : undefined;
3740
- message.level = object.level ?? 0;
3741
- message.message = object.message ?? "";
3742
- message.attributes = object.attributes ?? "";
3743
- message.runtimeInfo = (object.runtimeInfo !== undefined && object.runtimeInfo !== null)
3744
- ? exports.RuntimeInfo.fromPartial(object.runtimeInfo)
3745
- : undefined;
3746
- return message;
3747
- },
3748
- };
3749
- function createBaseEventTrackingResult() {
3750
- return { metadata: undefined, distinctEntityId: "", attributes: "", runtimeInfo: undefined };
3751
- }
3752
- exports.EventTrackingResult = {
3753
- encode(message, writer = minimal_1.default.Writer.create()) {
3754
- if (message.metadata !== undefined) {
3755
- exports.RecordMetaData.encode(message.metadata, writer.uint32(10).fork()).ldelim();
3756
- }
3757
- if (message.distinctEntityId !== "") {
3758
- writer.uint32(18).string(message.distinctEntityId);
3759
- }
3760
- if (message.attributes !== "") {
3761
- writer.uint32(34).string(message.attributes);
3762
- }
3763
- if (message.runtimeInfo !== undefined) {
3764
- exports.RuntimeInfo.encode(message.runtimeInfo, writer.uint32(42).fork()).ldelim();
3765
- }
3766
- return writer;
3767
- },
3768
- decode(input, length) {
3769
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3770
- let end = length === undefined ? reader.len : reader.pos + length;
3771
- const message = createBaseEventTrackingResult();
3772
- while (reader.pos < end) {
3773
- const tag = reader.uint32();
3774
- switch (tag >>> 3) {
3775
- case 1:
3776
- message.metadata = exports.RecordMetaData.decode(reader, reader.uint32());
3777
- break;
3778
- case 2:
3779
- message.distinctEntityId = reader.string();
3780
- break;
3781
- case 4:
3782
- message.attributes = reader.string();
3783
- break;
3784
- case 5:
3785
- message.runtimeInfo = exports.RuntimeInfo.decode(reader, reader.uint32());
3786
- break;
3787
- default:
3788
- reader.skipType(tag & 7);
3789
- break;
3790
- }
3791
- }
3792
- return message;
3793
- },
3794
- fromJSON(object) {
3795
- return {
3796
- metadata: isSet(object.metadata) ? exports.RecordMetaData.fromJSON(object.metadata) : undefined,
3797
- distinctEntityId: isSet(object.distinctEntityId) ? String(object.distinctEntityId) : "",
3798
- attributes: isSet(object.attributes) ? String(object.attributes) : "",
3799
- runtimeInfo: isSet(object.runtimeInfo) ? exports.RuntimeInfo.fromJSON(object.runtimeInfo) : undefined,
3800
- };
3801
- },
3802
- toJSON(message) {
3803
- const obj = {};
3804
- message.metadata !== undefined &&
3805
- (obj.metadata = message.metadata ? exports.RecordMetaData.toJSON(message.metadata) : undefined);
3806
- message.distinctEntityId !== undefined && (obj.distinctEntityId = message.distinctEntityId);
3807
- message.attributes !== undefined && (obj.attributes = message.attributes);
3808
- message.runtimeInfo !== undefined &&
3809
- (obj.runtimeInfo = message.runtimeInfo ? exports.RuntimeInfo.toJSON(message.runtimeInfo) : undefined);
3810
- return obj;
3811
- },
3812
- fromPartial(object) {
3813
- const message = createBaseEventTrackingResult();
3814
- message.metadata = (object.metadata !== undefined && object.metadata !== null)
3815
- ? exports.RecordMetaData.fromPartial(object.metadata)
3816
- : undefined;
3817
- message.distinctEntityId = object.distinctEntityId ?? "";
3818
- message.attributes = object.attributes ?? "";
3819
- message.runtimeInfo = (object.runtimeInfo !== undefined && object.runtimeInfo !== null)
3820
- ? exports.RuntimeInfo.fromPartial(object.runtimeInfo)
3821
- : undefined;
3822
- return message;
3823
- },
3824
- };
3825
- function createBaseExportResult() {
3826
- return { metadata: undefined, payload: "", runtimeInfo: undefined };
3827
- }
3828
- exports.ExportResult = {
3829
- encode(message, writer = minimal_1.default.Writer.create()) {
3830
- if (message.metadata !== undefined) {
3831
- exports.RecordMetaData.encode(message.metadata, writer.uint32(10).fork()).ldelim();
3832
- }
3833
- if (message.payload !== "") {
3834
- writer.uint32(18).string(message.payload);
3835
- }
3836
- if (message.runtimeInfo !== undefined) {
3837
- exports.RuntimeInfo.encode(message.runtimeInfo, writer.uint32(26).fork()).ldelim();
3838
- }
3839
- return writer;
3840
- },
3841
- decode(input, length) {
3842
- const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
3843
- let end = length === undefined ? reader.len : reader.pos + length;
3844
- const message = createBaseExportResult();
3845
- while (reader.pos < end) {
3846
- const tag = reader.uint32();
3847
- switch (tag >>> 3) {
3848
- case 1:
3849
- message.metadata = exports.RecordMetaData.decode(reader, reader.uint32());
3850
- break;
3851
- case 2:
3852
- message.payload = reader.string();
3853
- break;
3854
- case 3:
3855
- message.runtimeInfo = exports.RuntimeInfo.decode(reader, reader.uint32());
3856
- break;
3857
- default:
3858
- reader.skipType(tag & 7);
3859
- break;
3860
- }
3861
- }
3862
- return message;
3863
- },
3864
- fromJSON(object) {
3865
- return {
3866
- metadata: isSet(object.metadata) ? exports.RecordMetaData.fromJSON(object.metadata) : undefined,
3867
- payload: isSet(object.payload) ? String(object.payload) : "",
3868
- runtimeInfo: isSet(object.runtimeInfo) ? exports.RuntimeInfo.fromJSON(object.runtimeInfo) : undefined,
3869
- };
3870
- },
3871
- toJSON(message) {
3872
- const obj = {};
3873
- message.metadata !== undefined &&
3874
- (obj.metadata = message.metadata ? exports.RecordMetaData.toJSON(message.metadata) : undefined);
3875
- message.payload !== undefined && (obj.payload = message.payload);
3876
- message.runtimeInfo !== undefined &&
3877
- (obj.runtimeInfo = message.runtimeInfo ? exports.RuntimeInfo.toJSON(message.runtimeInfo) : undefined);
3878
- return obj;
3879
- },
3880
- fromPartial(object) {
3881
- const message = createBaseExportResult();
3882
- message.metadata = (object.metadata !== undefined && object.metadata !== null)
3883
- ? exports.RecordMetaData.fromPartial(object.metadata)
3884
- : undefined;
3885
- message.payload = object.payload ?? "";
3886
- message.runtimeInfo = (object.runtimeInfo !== undefined && object.runtimeInfo !== null)
3887
- ? exports.RuntimeInfo.fromPartial(object.runtimeInfo)
3888
- : undefined;
3889
- return message;
3890
- },
3891
- };
3892
- exports.ProcessorDefinition = {
3893
- name: "Processor",
3894
- fullName: "processor.Processor",
3895
- methods: {
3896
- start: {
3897
- name: "Start",
3898
- requestType: exports.StartRequest,
3899
- requestStream: false,
3900
- responseType: empty_1.Empty,
3901
- responseStream: false,
3902
- options: {},
3903
- },
3904
- stop: {
3905
- name: "Stop",
3906
- requestType: empty_1.Empty,
3907
- requestStream: false,
3908
- responseType: empty_1.Empty,
3909
- responseStream: false,
3910
- options: {},
3911
- },
3912
- getConfig: {
3913
- name: "GetConfig",
3914
- requestType: exports.ProcessConfigRequest,
3915
- requestStream: false,
3916
- responseType: exports.ProcessConfigResponse,
3917
- responseStream: false,
3918
- options: {},
3919
- },
3920
- processBindings: {
3921
- name: "ProcessBindings",
3922
- requestType: exports.ProcessBindingsRequest,
3923
- requestStream: false,
3924
- responseType: exports.ProcessBindingResponse,
3925
- responseStream: false,
3926
- options: {},
3927
- },
3928
- processBindingsStream: {
3929
- name: "ProcessBindingsStream",
3930
- requestType: exports.DataBinding,
3931
- requestStream: true,
3932
- responseType: exports.ProcessBindingResponse,
3933
- responseStream: true,
3934
- options: {},
3935
- },
3936
- },
3937
- };
3938
- var tsProtoGlobalThis = (() => {
3939
- if (typeof globalThis !== "undefined") {
3940
- return globalThis;
3941
- }
3942
- if (typeof self !== "undefined") {
3943
- return self;
3944
- }
3945
- if (typeof window !== "undefined") {
3946
- return window;
3947
- }
3948
- if (typeof global !== "undefined") {
3949
- return global;
3950
- }
3951
- throw "Unable to locate global object";
3952
- })();
3953
- function bytesFromBase64(b64) {
3954
- if (tsProtoGlobalThis.Buffer) {
3955
- return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
3956
- }
3957
- else {
3958
- const bin = tsProtoGlobalThis.atob(b64);
3959
- const arr = new Uint8Array(bin.length);
3960
- for (let i = 0; i < bin.length; ++i) {
3961
- arr[i] = bin.charCodeAt(i);
3962
- }
3963
- return arr;
3964
- }
3965
- }
3966
- function base64FromBytes(arr) {
3967
- if (tsProtoGlobalThis.Buffer) {
3968
- return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
3969
- }
3970
- else {
3971
- const bin = [];
3972
- arr.forEach((byte) => {
3973
- bin.push(String.fromCharCode(byte));
3974
- });
3975
- return tsProtoGlobalThis.btoa(bin.join(""));
3976
- }
3977
- }
3978
- if (minimal_1.default.util.Long !== long_1.default) {
3979
- minimal_1.default.util.Long = long_1.default;
3980
- minimal_1.default.configure();
3981
- }
3982
- function isObject(value) {
3983
- return typeof value === "object" && value !== null;
3984
- }
3985
- function isSet(value) {
3986
- return value !== null && value !== undefined;
3987
- }
3988
- //# sourceMappingURL=processor.js.map