@avaprotocol/sdk-js 0.6.5 → 0.6.6

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.
Files changed (12) hide show
  1. package/dist/index.cjs +4522 -0
  2. package/dist/index.d.cts +1504 -0
  3. package/dist/index.d.ts +1504 -0
  4. package/dist/index.js +4511 -0
  5. package/grpc_codegen/avs_grpc_pb.d.ts +632 -178
  6. package/grpc_codegen/avs_grpc_pb.js +4 -2
  7. package/grpc_codegen/avs_pb.d.ts +1 -1
  8. package/grpc_codegen/avs_pb.js +2 -0
  9. package/jest.config.cjs +4 -1
  10. package/package.json +1 -1
  11. package/src/index.ts +4 -9
  12. package/tsconfig.json +6 -5
package/dist/index.cjs ADDED
@@ -0,0 +1,4522 @@
1
+ "use strict";
2
+ var __create = Object.create;
3
+ var __defProp = Object.defineProperty;
4
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
+ var __getOwnPropNames = Object.getOwnPropertyNames;
6
+ var __getProtoOf = Object.getPrototypeOf;
7
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
8
+ var __esm = (fn, res) => function __init() {
9
+ return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
10
+ };
11
+ var __export = (target, all) => {
12
+ for (var name in all)
13
+ __defProp(target, name, { get: all[name], enumerable: true });
14
+ };
15
+ var __copyProps = (to, from, except, desc) => {
16
+ if (from && typeof from === "object" || typeof from === "function") {
17
+ for (let key of __getOwnPropNames(from))
18
+ if (!__hasOwnProp.call(to, key) && key !== except)
19
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
20
+ }
21
+ return to;
22
+ };
23
+ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
24
+ // If the importer is in node compatibility mode or this is not an ESM
25
+ // file that has been converted to a CommonJS file using a Babel-
26
+ // compatible transform (i.e. "__esModule" has not been set), then set
27
+ // "default" to the CommonJS "module.exports" for node compatibility.
28
+ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
29
+ mod
30
+ ));
31
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
32
+
33
+ // grpc_codegen/avs_pb.js
34
+ var avs_pb_exports = {};
35
+ __export(avs_pb_exports, {
36
+ CreateTaskReq: () => CreateTaskReq,
37
+ CreateTaskResp: () => CreateTaskResp,
38
+ GetKeyReq: () => GetKeyReq,
39
+ KeyResp: () => KeyResp,
40
+ Task: () => Task,
41
+ UpdateChecksReq: () => UpdateChecksReq,
42
+ UpdateChecksResp: () => UpdateChecksResp
43
+ });
44
+ var jspb, goog, global, google_protobuf_timestamp_pb, google_protobuf_wrappers_pb, Task, CreateTaskReq, CreateTaskResp, GetKeyReq, KeyResp, UpdateChecksReq, UpdateChecksResp;
45
+ var init_avs_pb = __esm({
46
+ "grpc_codegen/avs_pb.js"() {
47
+ "use strict";
48
+ jspb = require("google-protobuf");
49
+ goog = jspb;
50
+ global = function() {
51
+ if (this) {
52
+ return this;
53
+ }
54
+ if (typeof window !== "undefined") {
55
+ return window;
56
+ }
57
+ if (typeof global !== "undefined") {
58
+ return global;
59
+ }
60
+ if (typeof self !== "undefined") {
61
+ return self;
62
+ }
63
+ return Function("return this")();
64
+ }.call(null);
65
+ google_protobuf_timestamp_pb = require("google-protobuf/google/protobuf/timestamp_pb.js");
66
+ goog.object.extend(proto, google_protobuf_timestamp_pb);
67
+ google_protobuf_wrappers_pb = require("google-protobuf/google/protobuf/wrappers_pb.js");
68
+ goog.object.extend(proto, google_protobuf_wrappers_pb);
69
+ goog.exportSymbol("proto.aggregator.AddressRequest", null, global);
70
+ goog.exportSymbol("proto.aggregator.AddressResp", null, global);
71
+ goog.exportSymbol("proto.aggregator.BranchAction", null, global);
72
+ goog.exportSymbol("proto.aggregator.Checkin", null, global);
73
+ goog.exportSymbol("proto.aggregator.Checkin.Status", null, global);
74
+ goog.exportSymbol("proto.aggregator.CheckinResp", null, global);
75
+ goog.exportSymbol("proto.aggregator.ConditionJump", null, global);
76
+ goog.exportSymbol("proto.aggregator.ContractExecution", null, global);
77
+ goog.exportSymbol("proto.aggregator.ContractQueryCondition", null, global);
78
+ goog.exportSymbol("proto.aggregator.CreateTaskReq", null, global);
79
+ goog.exportSymbol("proto.aggregator.CreateTaskResp", null, global);
80
+ goog.exportSymbol("proto.aggregator.CustomCode", null, global);
81
+ goog.exportSymbol("proto.aggregator.CustomCodeType", null, global);
82
+ goog.exportSymbol("proto.aggregator.ETHTransfer", null, global);
83
+ goog.exportSymbol("proto.aggregator.Execution", null, global);
84
+ goog.exportSymbol("proto.aggregator.ExpressionCondition", null, global);
85
+ goog.exportSymbol("proto.aggregator.GetKeyReq", null, global);
86
+ goog.exportSymbol("proto.aggregator.GraphQLDataQuery", null, global);
87
+ goog.exportSymbol("proto.aggregator.HTTPAPICall", null, global);
88
+ goog.exportSymbol("proto.aggregator.KeyResp", null, global);
89
+ goog.exportSymbol("proto.aggregator.ListTasksReq", null, global);
90
+ goog.exportSymbol("proto.aggregator.ListTasksResp", null, global);
91
+ goog.exportSymbol("proto.aggregator.ListTasksResp.TaskItemResp", null, global);
92
+ goog.exportSymbol("proto.aggregator.NonceRequest", null, global);
93
+ goog.exportSymbol("proto.aggregator.NonceResp", null, global);
94
+ goog.exportSymbol("proto.aggregator.SyncTasksReq", null, global);
95
+ goog.exportSymbol("proto.aggregator.SyncTasksResp", null, global);
96
+ goog.exportSymbol("proto.aggregator.Task", null, global);
97
+ goog.exportSymbol("proto.aggregator.TaskAction", null, global);
98
+ goog.exportSymbol("proto.aggregator.TaskStatus", null, global);
99
+ goog.exportSymbol("proto.aggregator.TaskTrigger", null, global);
100
+ goog.exportSymbol("proto.aggregator.TaskType", null, global);
101
+ goog.exportSymbol("proto.aggregator.TimeCondition", null, global);
102
+ goog.exportSymbol("proto.aggregator.TriggerType", null, global);
103
+ goog.exportSymbol("proto.aggregator.UUID", null, global);
104
+ goog.exportSymbol("proto.aggregator.UpdateChecksReq", null, global);
105
+ goog.exportSymbol("proto.aggregator.UpdateChecksResp", null, global);
106
+ proto.aggregator.UUID = function(opt_data) {
107
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
108
+ };
109
+ goog.inherits(proto.aggregator.UUID, jspb.Message);
110
+ if (goog.DEBUG && !COMPILED) {
111
+ proto.aggregator.UUID.displayName = "proto.aggregator.UUID";
112
+ }
113
+ proto.aggregator.Checkin = function(opt_data) {
114
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
115
+ };
116
+ goog.inherits(proto.aggregator.Checkin, jspb.Message);
117
+ if (goog.DEBUG && !COMPILED) {
118
+ proto.aggregator.Checkin.displayName = "proto.aggregator.Checkin";
119
+ }
120
+ proto.aggregator.Checkin.Status = function(opt_data) {
121
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
122
+ };
123
+ goog.inherits(proto.aggregator.Checkin.Status, jspb.Message);
124
+ if (goog.DEBUG && !COMPILED) {
125
+ proto.aggregator.Checkin.Status.displayName = "proto.aggregator.Checkin.Status";
126
+ }
127
+ proto.aggregator.CheckinResp = function(opt_data) {
128
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
129
+ };
130
+ goog.inherits(proto.aggregator.CheckinResp, jspb.Message);
131
+ if (goog.DEBUG && !COMPILED) {
132
+ proto.aggregator.CheckinResp.displayName = "proto.aggregator.CheckinResp";
133
+ }
134
+ proto.aggregator.SyncTasksReq = function(opt_data) {
135
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
136
+ };
137
+ goog.inherits(proto.aggregator.SyncTasksReq, jspb.Message);
138
+ if (goog.DEBUG && !COMPILED) {
139
+ proto.aggregator.SyncTasksReq.displayName = "proto.aggregator.SyncTasksReq";
140
+ }
141
+ proto.aggregator.TaskTrigger = function(opt_data) {
142
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
143
+ };
144
+ goog.inherits(proto.aggregator.TaskTrigger, jspb.Message);
145
+ if (goog.DEBUG && !COMPILED) {
146
+ proto.aggregator.TaskTrigger.displayName = "proto.aggregator.TaskTrigger";
147
+ }
148
+ proto.aggregator.TimeCondition = function(opt_data) {
149
+ jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.TimeCondition.repeatedFields_, null);
150
+ };
151
+ goog.inherits(proto.aggregator.TimeCondition, jspb.Message);
152
+ if (goog.DEBUG && !COMPILED) {
153
+ proto.aggregator.TimeCondition.displayName = "proto.aggregator.TimeCondition";
154
+ }
155
+ proto.aggregator.ContractQueryCondition = function(opt_data) {
156
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
157
+ };
158
+ goog.inherits(proto.aggregator.ContractQueryCondition, jspb.Message);
159
+ if (goog.DEBUG && !COMPILED) {
160
+ proto.aggregator.ContractQueryCondition.displayName = "proto.aggregator.ContractQueryCondition";
161
+ }
162
+ proto.aggregator.ExpressionCondition = function(opt_data) {
163
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
164
+ };
165
+ goog.inherits(proto.aggregator.ExpressionCondition, jspb.Message);
166
+ if (goog.DEBUG && !COMPILED) {
167
+ proto.aggregator.ExpressionCondition.displayName = "proto.aggregator.ExpressionCondition";
168
+ }
169
+ proto.aggregator.SyncTasksResp = function(opt_data) {
170
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
171
+ };
172
+ goog.inherits(proto.aggregator.SyncTasksResp, jspb.Message);
173
+ if (goog.DEBUG && !COMPILED) {
174
+ proto.aggregator.SyncTasksResp.displayName = "proto.aggregator.SyncTasksResp";
175
+ }
176
+ proto.aggregator.ETHTransfer = function(opt_data) {
177
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
178
+ };
179
+ goog.inherits(proto.aggregator.ETHTransfer, jspb.Message);
180
+ if (goog.DEBUG && !COMPILED) {
181
+ proto.aggregator.ETHTransfer.displayName = "proto.aggregator.ETHTransfer";
182
+ }
183
+ proto.aggregator.ContractExecution = function(opt_data) {
184
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
185
+ };
186
+ goog.inherits(proto.aggregator.ContractExecution, jspb.Message);
187
+ if (goog.DEBUG && !COMPILED) {
188
+ proto.aggregator.ContractExecution.displayName = "proto.aggregator.ContractExecution";
189
+ }
190
+ proto.aggregator.GraphQLDataQuery = function(opt_data) {
191
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
192
+ };
193
+ goog.inherits(proto.aggregator.GraphQLDataQuery, jspb.Message);
194
+ if (goog.DEBUG && !COMPILED) {
195
+ proto.aggregator.GraphQLDataQuery.displayName = "proto.aggregator.GraphQLDataQuery";
196
+ }
197
+ proto.aggregator.HTTPAPICall = function(opt_data) {
198
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
199
+ };
200
+ goog.inherits(proto.aggregator.HTTPAPICall, jspb.Message);
201
+ if (goog.DEBUG && !COMPILED) {
202
+ proto.aggregator.HTTPAPICall.displayName = "proto.aggregator.HTTPAPICall";
203
+ }
204
+ proto.aggregator.CustomCode = function(opt_data) {
205
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
206
+ };
207
+ goog.inherits(proto.aggregator.CustomCode, jspb.Message);
208
+ if (goog.DEBUG && !COMPILED) {
209
+ proto.aggregator.CustomCode.displayName = "proto.aggregator.CustomCode";
210
+ }
211
+ proto.aggregator.ConditionJump = function(opt_data) {
212
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
213
+ };
214
+ goog.inherits(proto.aggregator.ConditionJump, jspb.Message);
215
+ if (goog.DEBUG && !COMPILED) {
216
+ proto.aggregator.ConditionJump.displayName = "proto.aggregator.ConditionJump";
217
+ }
218
+ proto.aggregator.BranchAction = function(opt_data) {
219
+ jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.BranchAction.repeatedFields_, null);
220
+ };
221
+ goog.inherits(proto.aggregator.BranchAction, jspb.Message);
222
+ if (goog.DEBUG && !COMPILED) {
223
+ proto.aggregator.BranchAction.displayName = "proto.aggregator.BranchAction";
224
+ }
225
+ proto.aggregator.TaskAction = function(opt_data) {
226
+ jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.TaskAction.repeatedFields_, null);
227
+ };
228
+ goog.inherits(proto.aggregator.TaskAction, jspb.Message);
229
+ if (goog.DEBUG && !COMPILED) {
230
+ proto.aggregator.TaskAction.displayName = "proto.aggregator.TaskAction";
231
+ }
232
+ proto.aggregator.Execution = function(opt_data) {
233
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
234
+ };
235
+ goog.inherits(proto.aggregator.Execution, jspb.Message);
236
+ if (goog.DEBUG && !COMPILED) {
237
+ proto.aggregator.Execution.displayName = "proto.aggregator.Execution";
238
+ }
239
+ proto.aggregator.Task = function(opt_data) {
240
+ jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.Task.repeatedFields_, null);
241
+ };
242
+ goog.inherits(proto.aggregator.Task, jspb.Message);
243
+ if (goog.DEBUG && !COMPILED) {
244
+ proto.aggregator.Task.displayName = "proto.aggregator.Task";
245
+ }
246
+ proto.aggregator.CreateTaskReq = function(opt_data) {
247
+ jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.CreateTaskReq.repeatedFields_, null);
248
+ };
249
+ goog.inherits(proto.aggregator.CreateTaskReq, jspb.Message);
250
+ if (goog.DEBUG && !COMPILED) {
251
+ proto.aggregator.CreateTaskReq.displayName = "proto.aggregator.CreateTaskReq";
252
+ }
253
+ proto.aggregator.CreateTaskResp = function(opt_data) {
254
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
255
+ };
256
+ goog.inherits(proto.aggregator.CreateTaskResp, jspb.Message);
257
+ if (goog.DEBUG && !COMPILED) {
258
+ proto.aggregator.CreateTaskResp.displayName = "proto.aggregator.CreateTaskResp";
259
+ }
260
+ proto.aggregator.NonceRequest = function(opt_data) {
261
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
262
+ };
263
+ goog.inherits(proto.aggregator.NonceRequest, jspb.Message);
264
+ if (goog.DEBUG && !COMPILED) {
265
+ proto.aggregator.NonceRequest.displayName = "proto.aggregator.NonceRequest";
266
+ }
267
+ proto.aggregator.NonceResp = function(opt_data) {
268
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
269
+ };
270
+ goog.inherits(proto.aggregator.NonceResp, jspb.Message);
271
+ if (goog.DEBUG && !COMPILED) {
272
+ proto.aggregator.NonceResp.displayName = "proto.aggregator.NonceResp";
273
+ }
274
+ proto.aggregator.AddressRequest = function(opt_data) {
275
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
276
+ };
277
+ goog.inherits(proto.aggregator.AddressRequest, jspb.Message);
278
+ if (goog.DEBUG && !COMPILED) {
279
+ proto.aggregator.AddressRequest.displayName = "proto.aggregator.AddressRequest";
280
+ }
281
+ proto.aggregator.AddressResp = function(opt_data) {
282
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
283
+ };
284
+ goog.inherits(proto.aggregator.AddressResp, jspb.Message);
285
+ if (goog.DEBUG && !COMPILED) {
286
+ proto.aggregator.AddressResp.displayName = "proto.aggregator.AddressResp";
287
+ }
288
+ proto.aggregator.ListTasksReq = function(opt_data) {
289
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
290
+ };
291
+ goog.inherits(proto.aggregator.ListTasksReq, jspb.Message);
292
+ if (goog.DEBUG && !COMPILED) {
293
+ proto.aggregator.ListTasksReq.displayName = "proto.aggregator.ListTasksReq";
294
+ }
295
+ proto.aggregator.ListTasksResp = function(opt_data) {
296
+ jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.ListTasksResp.repeatedFields_, null);
297
+ };
298
+ goog.inherits(proto.aggregator.ListTasksResp, jspb.Message);
299
+ if (goog.DEBUG && !COMPILED) {
300
+ proto.aggregator.ListTasksResp.displayName = "proto.aggregator.ListTasksResp";
301
+ }
302
+ proto.aggregator.ListTasksResp.TaskItemResp = function(opt_data) {
303
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
304
+ };
305
+ goog.inherits(proto.aggregator.ListTasksResp.TaskItemResp, jspb.Message);
306
+ if (goog.DEBUG && !COMPILED) {
307
+ proto.aggregator.ListTasksResp.TaskItemResp.displayName = "proto.aggregator.ListTasksResp.TaskItemResp";
308
+ }
309
+ proto.aggregator.GetKeyReq = function(opt_data) {
310
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
311
+ };
312
+ goog.inherits(proto.aggregator.GetKeyReq, jspb.Message);
313
+ if (goog.DEBUG && !COMPILED) {
314
+ proto.aggregator.GetKeyReq.displayName = "proto.aggregator.GetKeyReq";
315
+ }
316
+ proto.aggregator.KeyResp = function(opt_data) {
317
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
318
+ };
319
+ goog.inherits(proto.aggregator.KeyResp, jspb.Message);
320
+ if (goog.DEBUG && !COMPILED) {
321
+ proto.aggregator.KeyResp.displayName = "proto.aggregator.KeyResp";
322
+ }
323
+ proto.aggregator.UpdateChecksReq = function(opt_data) {
324
+ jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.UpdateChecksReq.repeatedFields_, null);
325
+ };
326
+ goog.inherits(proto.aggregator.UpdateChecksReq, jspb.Message);
327
+ if (goog.DEBUG && !COMPILED) {
328
+ proto.aggregator.UpdateChecksReq.displayName = "proto.aggregator.UpdateChecksReq";
329
+ }
330
+ proto.aggregator.UpdateChecksResp = function(opt_data) {
331
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
332
+ };
333
+ goog.inherits(proto.aggregator.UpdateChecksResp, jspb.Message);
334
+ if (goog.DEBUG && !COMPILED) {
335
+ proto.aggregator.UpdateChecksResp.displayName = "proto.aggregator.UpdateChecksResp";
336
+ }
337
+ if (jspb.Message.GENERATE_TO_OBJECT) {
338
+ proto.aggregator.UUID.prototype.toObject = function(opt_includeInstance) {
339
+ return proto.aggregator.UUID.toObject(opt_includeInstance, this);
340
+ };
341
+ proto.aggregator.UUID.toObject = function(includeInstance, msg) {
342
+ var f, obj = {
343
+ bytes: jspb.Message.getFieldWithDefault(msg, 1, "")
344
+ };
345
+ if (includeInstance) {
346
+ obj.$jspbMessageInstance = msg;
347
+ }
348
+ return obj;
349
+ };
350
+ }
351
+ proto.aggregator.UUID.deserializeBinary = function(bytes) {
352
+ var reader = new jspb.BinaryReader(bytes);
353
+ var msg = new proto.aggregator.UUID();
354
+ return proto.aggregator.UUID.deserializeBinaryFromReader(msg, reader);
355
+ };
356
+ proto.aggregator.UUID.deserializeBinaryFromReader = function(msg, reader) {
357
+ while (reader.nextField()) {
358
+ if (reader.isEndGroup()) {
359
+ break;
360
+ }
361
+ var field = reader.getFieldNumber();
362
+ switch (field) {
363
+ case 1:
364
+ var value = (
365
+ /** @type {string} */
366
+ reader.readString()
367
+ );
368
+ msg.setBytes(value);
369
+ break;
370
+ default:
371
+ reader.skipField();
372
+ break;
373
+ }
374
+ }
375
+ return msg;
376
+ };
377
+ proto.aggregator.UUID.prototype.serializeBinary = function() {
378
+ var writer = new jspb.BinaryWriter();
379
+ proto.aggregator.UUID.serializeBinaryToWriter(this, writer);
380
+ return writer.getResultBuffer();
381
+ };
382
+ proto.aggregator.UUID.serializeBinaryToWriter = function(message, writer) {
383
+ var f = void 0;
384
+ f = message.getBytes();
385
+ if (f.length > 0) {
386
+ writer.writeString(
387
+ 1,
388
+ f
389
+ );
390
+ }
391
+ };
392
+ proto.aggregator.UUID.prototype.getBytes = function() {
393
+ return (
394
+ /** @type {string} */
395
+ jspb.Message.getFieldWithDefault(this, 1, "")
396
+ );
397
+ };
398
+ proto.aggregator.UUID.prototype.setBytes = function(value) {
399
+ return jspb.Message.setProto3StringField(this, 1, value);
400
+ };
401
+ if (jspb.Message.GENERATE_TO_OBJECT) {
402
+ proto.aggregator.Checkin.prototype.toObject = function(opt_includeInstance) {
403
+ return proto.aggregator.Checkin.toObject(opt_includeInstance, this);
404
+ };
405
+ proto.aggregator.Checkin.toObject = function(includeInstance, msg) {
406
+ var f, obj = {
407
+ id: jspb.Message.getFieldWithDefault(msg, 1, ""),
408
+ address: jspb.Message.getFieldWithDefault(msg, 2, ""),
409
+ signature: jspb.Message.getFieldWithDefault(msg, 3, ""),
410
+ status: (f = msg.getStatus()) && proto.aggregator.Checkin.Status.toObject(includeInstance, f),
411
+ version: jspb.Message.getFieldWithDefault(msg, 5, ""),
412
+ metricsport: jspb.Message.getFieldWithDefault(msg, 6, 0),
413
+ remoteip: jspb.Message.getFieldWithDefault(msg, 7, "")
414
+ };
415
+ if (includeInstance) {
416
+ obj.$jspbMessageInstance = msg;
417
+ }
418
+ return obj;
419
+ };
420
+ }
421
+ proto.aggregator.Checkin.deserializeBinary = function(bytes) {
422
+ var reader = new jspb.BinaryReader(bytes);
423
+ var msg = new proto.aggregator.Checkin();
424
+ return proto.aggregator.Checkin.deserializeBinaryFromReader(msg, reader);
425
+ };
426
+ proto.aggregator.Checkin.deserializeBinaryFromReader = function(msg, reader) {
427
+ while (reader.nextField()) {
428
+ if (reader.isEndGroup()) {
429
+ break;
430
+ }
431
+ var field = reader.getFieldNumber();
432
+ switch (field) {
433
+ case 1:
434
+ var value = (
435
+ /** @type {string} */
436
+ reader.readString()
437
+ );
438
+ msg.setId(value);
439
+ break;
440
+ case 2:
441
+ var value = (
442
+ /** @type {string} */
443
+ reader.readString()
444
+ );
445
+ msg.setAddress(value);
446
+ break;
447
+ case 3:
448
+ var value = (
449
+ /** @type {string} */
450
+ reader.readString()
451
+ );
452
+ msg.setSignature(value);
453
+ break;
454
+ case 4:
455
+ var value = new proto.aggregator.Checkin.Status();
456
+ reader.readMessage(value, proto.aggregator.Checkin.Status.deserializeBinaryFromReader);
457
+ msg.setStatus(value);
458
+ break;
459
+ case 5:
460
+ var value = (
461
+ /** @type {string} */
462
+ reader.readString()
463
+ );
464
+ msg.setVersion(value);
465
+ break;
466
+ case 6:
467
+ var value = (
468
+ /** @type {number} */
469
+ reader.readInt32()
470
+ );
471
+ msg.setMetricsport(value);
472
+ break;
473
+ case 7:
474
+ var value = (
475
+ /** @type {string} */
476
+ reader.readString()
477
+ );
478
+ msg.setRemoteip(value);
479
+ break;
480
+ default:
481
+ reader.skipField();
482
+ break;
483
+ }
484
+ }
485
+ return msg;
486
+ };
487
+ proto.aggregator.Checkin.prototype.serializeBinary = function() {
488
+ var writer = new jspb.BinaryWriter();
489
+ proto.aggregator.Checkin.serializeBinaryToWriter(this, writer);
490
+ return writer.getResultBuffer();
491
+ };
492
+ proto.aggregator.Checkin.serializeBinaryToWriter = function(message, writer) {
493
+ var f = void 0;
494
+ f = message.getId();
495
+ if (f.length > 0) {
496
+ writer.writeString(
497
+ 1,
498
+ f
499
+ );
500
+ }
501
+ f = message.getAddress();
502
+ if (f.length > 0) {
503
+ writer.writeString(
504
+ 2,
505
+ f
506
+ );
507
+ }
508
+ f = message.getSignature();
509
+ if (f.length > 0) {
510
+ writer.writeString(
511
+ 3,
512
+ f
513
+ );
514
+ }
515
+ f = message.getStatus();
516
+ if (f != null) {
517
+ writer.writeMessage(
518
+ 4,
519
+ f,
520
+ proto.aggregator.Checkin.Status.serializeBinaryToWriter
521
+ );
522
+ }
523
+ f = message.getVersion();
524
+ if (f.length > 0) {
525
+ writer.writeString(
526
+ 5,
527
+ f
528
+ );
529
+ }
530
+ f = message.getMetricsport();
531
+ if (f !== 0) {
532
+ writer.writeInt32(
533
+ 6,
534
+ f
535
+ );
536
+ }
537
+ f = message.getRemoteip();
538
+ if (f.length > 0) {
539
+ writer.writeString(
540
+ 7,
541
+ f
542
+ );
543
+ }
544
+ };
545
+ if (jspb.Message.GENERATE_TO_OBJECT) {
546
+ proto.aggregator.Checkin.Status.prototype.toObject = function(opt_includeInstance) {
547
+ return proto.aggregator.Checkin.Status.toObject(opt_includeInstance, this);
548
+ };
549
+ proto.aggregator.Checkin.Status.toObject = function(includeInstance, msg) {
550
+ var f, obj = {
551
+ uptime: jspb.Message.getFieldWithDefault(msg, 1, 0),
552
+ queuedepth: jspb.Message.getFieldWithDefault(msg, 2, 0),
553
+ lastHeartbeat: (f = msg.getLastHeartbeat()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f)
554
+ };
555
+ if (includeInstance) {
556
+ obj.$jspbMessageInstance = msg;
557
+ }
558
+ return obj;
559
+ };
560
+ }
561
+ proto.aggregator.Checkin.Status.deserializeBinary = function(bytes) {
562
+ var reader = new jspb.BinaryReader(bytes);
563
+ var msg = new proto.aggregator.Checkin.Status();
564
+ return proto.aggregator.Checkin.Status.deserializeBinaryFromReader(msg, reader);
565
+ };
566
+ proto.aggregator.Checkin.Status.deserializeBinaryFromReader = function(msg, reader) {
567
+ while (reader.nextField()) {
568
+ if (reader.isEndGroup()) {
569
+ break;
570
+ }
571
+ var field = reader.getFieldNumber();
572
+ switch (field) {
573
+ case 1:
574
+ var value = (
575
+ /** @type {number} */
576
+ reader.readInt64()
577
+ );
578
+ msg.setUptime(value);
579
+ break;
580
+ case 2:
581
+ var value = (
582
+ /** @type {number} */
583
+ reader.readInt64()
584
+ );
585
+ msg.setQueuedepth(value);
586
+ break;
587
+ case 3:
588
+ var value = new google_protobuf_timestamp_pb.Timestamp();
589
+ reader.readMessage(value, google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader);
590
+ msg.setLastHeartbeat(value);
591
+ break;
592
+ default:
593
+ reader.skipField();
594
+ break;
595
+ }
596
+ }
597
+ return msg;
598
+ };
599
+ proto.aggregator.Checkin.Status.prototype.serializeBinary = function() {
600
+ var writer = new jspb.BinaryWriter();
601
+ proto.aggregator.Checkin.Status.serializeBinaryToWriter(this, writer);
602
+ return writer.getResultBuffer();
603
+ };
604
+ proto.aggregator.Checkin.Status.serializeBinaryToWriter = function(message, writer) {
605
+ var f = void 0;
606
+ f = message.getUptime();
607
+ if (f !== 0) {
608
+ writer.writeInt64(
609
+ 1,
610
+ f
611
+ );
612
+ }
613
+ f = message.getQueuedepth();
614
+ if (f !== 0) {
615
+ writer.writeInt64(
616
+ 2,
617
+ f
618
+ );
619
+ }
620
+ f = message.getLastHeartbeat();
621
+ if (f != null) {
622
+ writer.writeMessage(
623
+ 3,
624
+ f,
625
+ google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter
626
+ );
627
+ }
628
+ };
629
+ proto.aggregator.Checkin.Status.prototype.getUptime = function() {
630
+ return (
631
+ /** @type {number} */
632
+ jspb.Message.getFieldWithDefault(this, 1, 0)
633
+ );
634
+ };
635
+ proto.aggregator.Checkin.Status.prototype.setUptime = function(value) {
636
+ return jspb.Message.setProto3IntField(this, 1, value);
637
+ };
638
+ proto.aggregator.Checkin.Status.prototype.getQueuedepth = function() {
639
+ return (
640
+ /** @type {number} */
641
+ jspb.Message.getFieldWithDefault(this, 2, 0)
642
+ );
643
+ };
644
+ proto.aggregator.Checkin.Status.prototype.setQueuedepth = function(value) {
645
+ return jspb.Message.setProto3IntField(this, 2, value);
646
+ };
647
+ proto.aggregator.Checkin.Status.prototype.getLastHeartbeat = function() {
648
+ return (
649
+ /** @type{?proto.google.protobuf.Timestamp} */
650
+ jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 3)
651
+ );
652
+ };
653
+ proto.aggregator.Checkin.Status.prototype.setLastHeartbeat = function(value) {
654
+ return jspb.Message.setWrapperField(this, 3, value);
655
+ };
656
+ proto.aggregator.Checkin.Status.prototype.clearLastHeartbeat = function() {
657
+ return this.setLastHeartbeat(void 0);
658
+ };
659
+ proto.aggregator.Checkin.Status.prototype.hasLastHeartbeat = function() {
660
+ return jspb.Message.getField(this, 3) != null;
661
+ };
662
+ proto.aggregator.Checkin.prototype.getId = function() {
663
+ return (
664
+ /** @type {string} */
665
+ jspb.Message.getFieldWithDefault(this, 1, "")
666
+ );
667
+ };
668
+ proto.aggregator.Checkin.prototype.setId = function(value) {
669
+ return jspb.Message.setProto3StringField(this, 1, value);
670
+ };
671
+ proto.aggregator.Checkin.prototype.getAddress = function() {
672
+ return (
673
+ /** @type {string} */
674
+ jspb.Message.getFieldWithDefault(this, 2, "")
675
+ );
676
+ };
677
+ proto.aggregator.Checkin.prototype.setAddress = function(value) {
678
+ return jspb.Message.setProto3StringField(this, 2, value);
679
+ };
680
+ proto.aggregator.Checkin.prototype.getSignature = function() {
681
+ return (
682
+ /** @type {string} */
683
+ jspb.Message.getFieldWithDefault(this, 3, "")
684
+ );
685
+ };
686
+ proto.aggregator.Checkin.prototype.setSignature = function(value) {
687
+ return jspb.Message.setProto3StringField(this, 3, value);
688
+ };
689
+ proto.aggregator.Checkin.prototype.getStatus = function() {
690
+ return (
691
+ /** @type{?proto.aggregator.Checkin.Status} */
692
+ jspb.Message.getWrapperField(this, proto.aggregator.Checkin.Status, 4)
693
+ );
694
+ };
695
+ proto.aggregator.Checkin.prototype.setStatus = function(value) {
696
+ return jspb.Message.setWrapperField(this, 4, value);
697
+ };
698
+ proto.aggregator.Checkin.prototype.clearStatus = function() {
699
+ return this.setStatus(void 0);
700
+ };
701
+ proto.aggregator.Checkin.prototype.hasStatus = function() {
702
+ return jspb.Message.getField(this, 4) != null;
703
+ };
704
+ proto.aggregator.Checkin.prototype.getVersion = function() {
705
+ return (
706
+ /** @type {string} */
707
+ jspb.Message.getFieldWithDefault(this, 5, "")
708
+ );
709
+ };
710
+ proto.aggregator.Checkin.prototype.setVersion = function(value) {
711
+ return jspb.Message.setProto3StringField(this, 5, value);
712
+ };
713
+ proto.aggregator.Checkin.prototype.getMetricsport = function() {
714
+ return (
715
+ /** @type {number} */
716
+ jspb.Message.getFieldWithDefault(this, 6, 0)
717
+ );
718
+ };
719
+ proto.aggregator.Checkin.prototype.setMetricsport = function(value) {
720
+ return jspb.Message.setProto3IntField(this, 6, value);
721
+ };
722
+ proto.aggregator.Checkin.prototype.getRemoteip = function() {
723
+ return (
724
+ /** @type {string} */
725
+ jspb.Message.getFieldWithDefault(this, 7, "")
726
+ );
727
+ };
728
+ proto.aggregator.Checkin.prototype.setRemoteip = function(value) {
729
+ return jspb.Message.setProto3StringField(this, 7, value);
730
+ };
731
+ if (jspb.Message.GENERATE_TO_OBJECT) {
732
+ proto.aggregator.CheckinResp.prototype.toObject = function(opt_includeInstance) {
733
+ return proto.aggregator.CheckinResp.toObject(opt_includeInstance, this);
734
+ };
735
+ proto.aggregator.CheckinResp.toObject = function(includeInstance, msg) {
736
+ var f, obj = {
737
+ updatedAt: (f = msg.getUpdatedAt()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f)
738
+ };
739
+ if (includeInstance) {
740
+ obj.$jspbMessageInstance = msg;
741
+ }
742
+ return obj;
743
+ };
744
+ }
745
+ proto.aggregator.CheckinResp.deserializeBinary = function(bytes) {
746
+ var reader = new jspb.BinaryReader(bytes);
747
+ var msg = new proto.aggregator.CheckinResp();
748
+ return proto.aggregator.CheckinResp.deserializeBinaryFromReader(msg, reader);
749
+ };
750
+ proto.aggregator.CheckinResp.deserializeBinaryFromReader = function(msg, reader) {
751
+ while (reader.nextField()) {
752
+ if (reader.isEndGroup()) {
753
+ break;
754
+ }
755
+ var field = reader.getFieldNumber();
756
+ switch (field) {
757
+ case 1:
758
+ var value = new google_protobuf_timestamp_pb.Timestamp();
759
+ reader.readMessage(value, google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader);
760
+ msg.setUpdatedAt(value);
761
+ break;
762
+ default:
763
+ reader.skipField();
764
+ break;
765
+ }
766
+ }
767
+ return msg;
768
+ };
769
+ proto.aggregator.CheckinResp.prototype.serializeBinary = function() {
770
+ var writer = new jspb.BinaryWriter();
771
+ proto.aggregator.CheckinResp.serializeBinaryToWriter(this, writer);
772
+ return writer.getResultBuffer();
773
+ };
774
+ proto.aggregator.CheckinResp.serializeBinaryToWriter = function(message, writer) {
775
+ var f = void 0;
776
+ f = message.getUpdatedAt();
777
+ if (f != null) {
778
+ writer.writeMessage(
779
+ 1,
780
+ f,
781
+ google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter
782
+ );
783
+ }
784
+ };
785
+ proto.aggregator.CheckinResp.prototype.getUpdatedAt = function() {
786
+ return (
787
+ /** @type{?proto.google.protobuf.Timestamp} */
788
+ jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 1)
789
+ );
790
+ };
791
+ proto.aggregator.CheckinResp.prototype.setUpdatedAt = function(value) {
792
+ return jspb.Message.setWrapperField(this, 1, value);
793
+ };
794
+ proto.aggregator.CheckinResp.prototype.clearUpdatedAt = function() {
795
+ return this.setUpdatedAt(void 0);
796
+ };
797
+ proto.aggregator.CheckinResp.prototype.hasUpdatedAt = function() {
798
+ return jspb.Message.getField(this, 1) != null;
799
+ };
800
+ if (jspb.Message.GENERATE_TO_OBJECT) {
801
+ proto.aggregator.SyncTasksReq.prototype.toObject = function(opt_includeInstance) {
802
+ return proto.aggregator.SyncTasksReq.toObject(opt_includeInstance, this);
803
+ };
804
+ proto.aggregator.SyncTasksReq.toObject = function(includeInstance, msg) {
805
+ var f, obj = {
806
+ id: jspb.Message.getFieldWithDefault(msg, 1, ""),
807
+ address: jspb.Message.getFieldWithDefault(msg, 2, ""),
808
+ signature: jspb.Message.getFieldWithDefault(msg, 3, ""),
809
+ monotonicClock: jspb.Message.getFieldWithDefault(msg, 4, 0)
810
+ };
811
+ if (includeInstance) {
812
+ obj.$jspbMessageInstance = msg;
813
+ }
814
+ return obj;
815
+ };
816
+ }
817
+ proto.aggregator.SyncTasksReq.deserializeBinary = function(bytes) {
818
+ var reader = new jspb.BinaryReader(bytes);
819
+ var msg = new proto.aggregator.SyncTasksReq();
820
+ return proto.aggregator.SyncTasksReq.deserializeBinaryFromReader(msg, reader);
821
+ };
822
+ proto.aggregator.SyncTasksReq.deserializeBinaryFromReader = function(msg, reader) {
823
+ while (reader.nextField()) {
824
+ if (reader.isEndGroup()) {
825
+ break;
826
+ }
827
+ var field = reader.getFieldNumber();
828
+ switch (field) {
829
+ case 1:
830
+ var value = (
831
+ /** @type {string} */
832
+ reader.readString()
833
+ );
834
+ msg.setId(value);
835
+ break;
836
+ case 2:
837
+ var value = (
838
+ /** @type {string} */
839
+ reader.readString()
840
+ );
841
+ msg.setAddress(value);
842
+ break;
843
+ case 3:
844
+ var value = (
845
+ /** @type {string} */
846
+ reader.readString()
847
+ );
848
+ msg.setSignature(value);
849
+ break;
850
+ case 4:
851
+ var value = (
852
+ /** @type {number} */
853
+ reader.readInt64()
854
+ );
855
+ msg.setMonotonicClock(value);
856
+ break;
857
+ default:
858
+ reader.skipField();
859
+ break;
860
+ }
861
+ }
862
+ return msg;
863
+ };
864
+ proto.aggregator.SyncTasksReq.prototype.serializeBinary = function() {
865
+ var writer = new jspb.BinaryWriter();
866
+ proto.aggregator.SyncTasksReq.serializeBinaryToWriter(this, writer);
867
+ return writer.getResultBuffer();
868
+ };
869
+ proto.aggregator.SyncTasksReq.serializeBinaryToWriter = function(message, writer) {
870
+ var f = void 0;
871
+ f = message.getId();
872
+ if (f.length > 0) {
873
+ writer.writeString(
874
+ 1,
875
+ f
876
+ );
877
+ }
878
+ f = message.getAddress();
879
+ if (f.length > 0) {
880
+ writer.writeString(
881
+ 2,
882
+ f
883
+ );
884
+ }
885
+ f = message.getSignature();
886
+ if (f.length > 0) {
887
+ writer.writeString(
888
+ 3,
889
+ f
890
+ );
891
+ }
892
+ f = message.getMonotonicClock();
893
+ if (f !== 0) {
894
+ writer.writeInt64(
895
+ 4,
896
+ f
897
+ );
898
+ }
899
+ };
900
+ proto.aggregator.SyncTasksReq.prototype.getId = function() {
901
+ return (
902
+ /** @type {string} */
903
+ jspb.Message.getFieldWithDefault(this, 1, "")
904
+ );
905
+ };
906
+ proto.aggregator.SyncTasksReq.prototype.setId = function(value) {
907
+ return jspb.Message.setProto3StringField(this, 1, value);
908
+ };
909
+ proto.aggregator.SyncTasksReq.prototype.getAddress = function() {
910
+ return (
911
+ /** @type {string} */
912
+ jspb.Message.getFieldWithDefault(this, 2, "")
913
+ );
914
+ };
915
+ proto.aggregator.SyncTasksReq.prototype.setAddress = function(value) {
916
+ return jspb.Message.setProto3StringField(this, 2, value);
917
+ };
918
+ proto.aggregator.SyncTasksReq.prototype.getSignature = function() {
919
+ return (
920
+ /** @type {string} */
921
+ jspb.Message.getFieldWithDefault(this, 3, "")
922
+ );
923
+ };
924
+ proto.aggregator.SyncTasksReq.prototype.setSignature = function(value) {
925
+ return jspb.Message.setProto3StringField(this, 3, value);
926
+ };
927
+ proto.aggregator.SyncTasksReq.prototype.getMonotonicClock = function() {
928
+ return (
929
+ /** @type {number} */
930
+ jspb.Message.getFieldWithDefault(this, 4, 0)
931
+ );
932
+ };
933
+ proto.aggregator.SyncTasksReq.prototype.setMonotonicClock = function(value) {
934
+ return jspb.Message.setProto3IntField(this, 4, value);
935
+ };
936
+ if (jspb.Message.GENERATE_TO_OBJECT) {
937
+ proto.aggregator.TaskTrigger.prototype.toObject = function(opt_includeInstance) {
938
+ return proto.aggregator.TaskTrigger.toObject(opt_includeInstance, this);
939
+ };
940
+ proto.aggregator.TaskTrigger.toObject = function(includeInstance, msg) {
941
+ var f, obj = {
942
+ triggerType: jspb.Message.getFieldWithDefault(msg, 1, 0),
943
+ schedule: (f = msg.getSchedule()) && proto.aggregator.TimeCondition.toObject(includeInstance, f),
944
+ contractQuery: (f = msg.getContractQuery()) && proto.aggregator.ContractQueryCondition.toObject(includeInstance, f),
945
+ expression: (f = msg.getExpression()) && proto.aggregator.ExpressionCondition.toObject(includeInstance, f)
946
+ };
947
+ if (includeInstance) {
948
+ obj.$jspbMessageInstance = msg;
949
+ }
950
+ return obj;
951
+ };
952
+ }
953
+ proto.aggregator.TaskTrigger.deserializeBinary = function(bytes) {
954
+ var reader = new jspb.BinaryReader(bytes);
955
+ var msg = new proto.aggregator.TaskTrigger();
956
+ return proto.aggregator.TaskTrigger.deserializeBinaryFromReader(msg, reader);
957
+ };
958
+ proto.aggregator.TaskTrigger.deserializeBinaryFromReader = function(msg, reader) {
959
+ while (reader.nextField()) {
960
+ if (reader.isEndGroup()) {
961
+ break;
962
+ }
963
+ var field = reader.getFieldNumber();
964
+ switch (field) {
965
+ case 1:
966
+ var value = (
967
+ /** @type {!proto.aggregator.TriggerType} */
968
+ reader.readEnum()
969
+ );
970
+ msg.setTriggerType(value);
971
+ break;
972
+ case 2:
973
+ var value = new proto.aggregator.TimeCondition();
974
+ reader.readMessage(value, proto.aggregator.TimeCondition.deserializeBinaryFromReader);
975
+ msg.setSchedule(value);
976
+ break;
977
+ case 3:
978
+ var value = new proto.aggregator.ContractQueryCondition();
979
+ reader.readMessage(value, proto.aggregator.ContractQueryCondition.deserializeBinaryFromReader);
980
+ msg.setContractQuery(value);
981
+ break;
982
+ case 4:
983
+ var value = new proto.aggregator.ExpressionCondition();
984
+ reader.readMessage(value, proto.aggregator.ExpressionCondition.deserializeBinaryFromReader);
985
+ msg.setExpression(value);
986
+ break;
987
+ default:
988
+ reader.skipField();
989
+ break;
990
+ }
991
+ }
992
+ return msg;
993
+ };
994
+ proto.aggregator.TaskTrigger.prototype.serializeBinary = function() {
995
+ var writer = new jspb.BinaryWriter();
996
+ proto.aggregator.TaskTrigger.serializeBinaryToWriter(this, writer);
997
+ return writer.getResultBuffer();
998
+ };
999
+ proto.aggregator.TaskTrigger.serializeBinaryToWriter = function(message, writer) {
1000
+ var f = void 0;
1001
+ f = message.getTriggerType();
1002
+ if (f !== 0) {
1003
+ writer.writeEnum(
1004
+ 1,
1005
+ f
1006
+ );
1007
+ }
1008
+ f = message.getSchedule();
1009
+ if (f != null) {
1010
+ writer.writeMessage(
1011
+ 2,
1012
+ f,
1013
+ proto.aggregator.TimeCondition.serializeBinaryToWriter
1014
+ );
1015
+ }
1016
+ f = message.getContractQuery();
1017
+ if (f != null) {
1018
+ writer.writeMessage(
1019
+ 3,
1020
+ f,
1021
+ proto.aggregator.ContractQueryCondition.serializeBinaryToWriter
1022
+ );
1023
+ }
1024
+ f = message.getExpression();
1025
+ if (f != null) {
1026
+ writer.writeMessage(
1027
+ 4,
1028
+ f,
1029
+ proto.aggregator.ExpressionCondition.serializeBinaryToWriter
1030
+ );
1031
+ }
1032
+ };
1033
+ proto.aggregator.TaskTrigger.prototype.getTriggerType = function() {
1034
+ return (
1035
+ /** @type {!proto.aggregator.TriggerType} */
1036
+ jspb.Message.getFieldWithDefault(this, 1, 0)
1037
+ );
1038
+ };
1039
+ proto.aggregator.TaskTrigger.prototype.setTriggerType = function(value) {
1040
+ return jspb.Message.setProto3EnumField(this, 1, value);
1041
+ };
1042
+ proto.aggregator.TaskTrigger.prototype.getSchedule = function() {
1043
+ return (
1044
+ /** @type{?proto.aggregator.TimeCondition} */
1045
+ jspb.Message.getWrapperField(this, proto.aggregator.TimeCondition, 2)
1046
+ );
1047
+ };
1048
+ proto.aggregator.TaskTrigger.prototype.setSchedule = function(value) {
1049
+ return jspb.Message.setWrapperField(this, 2, value);
1050
+ };
1051
+ proto.aggregator.TaskTrigger.prototype.clearSchedule = function() {
1052
+ return this.setSchedule(void 0);
1053
+ };
1054
+ proto.aggregator.TaskTrigger.prototype.hasSchedule = function() {
1055
+ return jspb.Message.getField(this, 2) != null;
1056
+ };
1057
+ proto.aggregator.TaskTrigger.prototype.getContractQuery = function() {
1058
+ return (
1059
+ /** @type{?proto.aggregator.ContractQueryCondition} */
1060
+ jspb.Message.getWrapperField(this, proto.aggregator.ContractQueryCondition, 3)
1061
+ );
1062
+ };
1063
+ proto.aggregator.TaskTrigger.prototype.setContractQuery = function(value) {
1064
+ return jspb.Message.setWrapperField(this, 3, value);
1065
+ };
1066
+ proto.aggregator.TaskTrigger.prototype.clearContractQuery = function() {
1067
+ return this.setContractQuery(void 0);
1068
+ };
1069
+ proto.aggregator.TaskTrigger.prototype.hasContractQuery = function() {
1070
+ return jspb.Message.getField(this, 3) != null;
1071
+ };
1072
+ proto.aggregator.TaskTrigger.prototype.getExpression = function() {
1073
+ return (
1074
+ /** @type{?proto.aggregator.ExpressionCondition} */
1075
+ jspb.Message.getWrapperField(this, proto.aggregator.ExpressionCondition, 4)
1076
+ );
1077
+ };
1078
+ proto.aggregator.TaskTrigger.prototype.setExpression = function(value) {
1079
+ return jspb.Message.setWrapperField(this, 4, value);
1080
+ };
1081
+ proto.aggregator.TaskTrigger.prototype.clearExpression = function() {
1082
+ return this.setExpression(void 0);
1083
+ };
1084
+ proto.aggregator.TaskTrigger.prototype.hasExpression = function() {
1085
+ return jspb.Message.getField(this, 4) != null;
1086
+ };
1087
+ proto.aggregator.TimeCondition.repeatedFields_ = [1];
1088
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1089
+ proto.aggregator.TimeCondition.prototype.toObject = function(opt_includeInstance) {
1090
+ return proto.aggregator.TimeCondition.toObject(opt_includeInstance, this);
1091
+ };
1092
+ proto.aggregator.TimeCondition.toObject = function(includeInstance, msg) {
1093
+ var f, obj = {
1094
+ fixedList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? void 0 : f,
1095
+ cron: jspb.Message.getFieldWithDefault(msg, 2, "")
1096
+ };
1097
+ if (includeInstance) {
1098
+ obj.$jspbMessageInstance = msg;
1099
+ }
1100
+ return obj;
1101
+ };
1102
+ }
1103
+ proto.aggregator.TimeCondition.deserializeBinary = function(bytes) {
1104
+ var reader = new jspb.BinaryReader(bytes);
1105
+ var msg = new proto.aggregator.TimeCondition();
1106
+ return proto.aggregator.TimeCondition.deserializeBinaryFromReader(msg, reader);
1107
+ };
1108
+ proto.aggregator.TimeCondition.deserializeBinaryFromReader = function(msg, reader) {
1109
+ while (reader.nextField()) {
1110
+ if (reader.isEndGroup()) {
1111
+ break;
1112
+ }
1113
+ var field = reader.getFieldNumber();
1114
+ switch (field) {
1115
+ case 1:
1116
+ var values = (
1117
+ /** @type {!Array<number>} */
1118
+ reader.isDelimited() ? reader.readPackedInt64() : [reader.readInt64()]
1119
+ );
1120
+ for (var i = 0; i < values.length; i++) {
1121
+ msg.addFixed(values[i]);
1122
+ }
1123
+ break;
1124
+ case 2:
1125
+ var value = (
1126
+ /** @type {string} */
1127
+ reader.readString()
1128
+ );
1129
+ msg.setCron(value);
1130
+ break;
1131
+ default:
1132
+ reader.skipField();
1133
+ break;
1134
+ }
1135
+ }
1136
+ return msg;
1137
+ };
1138
+ proto.aggregator.TimeCondition.prototype.serializeBinary = function() {
1139
+ var writer = new jspb.BinaryWriter();
1140
+ proto.aggregator.TimeCondition.serializeBinaryToWriter(this, writer);
1141
+ return writer.getResultBuffer();
1142
+ };
1143
+ proto.aggregator.TimeCondition.serializeBinaryToWriter = function(message, writer) {
1144
+ var f = void 0;
1145
+ f = message.getFixedList();
1146
+ if (f.length > 0) {
1147
+ writer.writePackedInt64(
1148
+ 1,
1149
+ f
1150
+ );
1151
+ }
1152
+ f = message.getCron();
1153
+ if (f.length > 0) {
1154
+ writer.writeString(
1155
+ 2,
1156
+ f
1157
+ );
1158
+ }
1159
+ };
1160
+ proto.aggregator.TimeCondition.prototype.getFixedList = function() {
1161
+ return (
1162
+ /** @type {!Array<number>} */
1163
+ jspb.Message.getRepeatedField(this, 1)
1164
+ );
1165
+ };
1166
+ proto.aggregator.TimeCondition.prototype.setFixedList = function(value) {
1167
+ return jspb.Message.setField(this, 1, value || []);
1168
+ };
1169
+ proto.aggregator.TimeCondition.prototype.addFixed = function(value, opt_index) {
1170
+ return jspb.Message.addToRepeatedField(this, 1, value, opt_index);
1171
+ };
1172
+ proto.aggregator.TimeCondition.prototype.clearFixedList = function() {
1173
+ return this.setFixedList([]);
1174
+ };
1175
+ proto.aggregator.TimeCondition.prototype.getCron = function() {
1176
+ return (
1177
+ /** @type {string} */
1178
+ jspb.Message.getFieldWithDefault(this, 2, "")
1179
+ );
1180
+ };
1181
+ proto.aggregator.TimeCondition.prototype.setCron = function(value) {
1182
+ return jspb.Message.setProto3StringField(this, 2, value);
1183
+ };
1184
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1185
+ proto.aggregator.ContractQueryCondition.prototype.toObject = function(opt_includeInstance) {
1186
+ return proto.aggregator.ContractQueryCondition.toObject(opt_includeInstance, this);
1187
+ };
1188
+ proto.aggregator.ContractQueryCondition.toObject = function(includeInstance, msg) {
1189
+ var f, obj = {
1190
+ contractAddress: jspb.Message.getFieldWithDefault(msg, 1, ""),
1191
+ callmsg: jspb.Message.getFieldWithDefault(msg, 2, "")
1192
+ };
1193
+ if (includeInstance) {
1194
+ obj.$jspbMessageInstance = msg;
1195
+ }
1196
+ return obj;
1197
+ };
1198
+ }
1199
+ proto.aggregator.ContractQueryCondition.deserializeBinary = function(bytes) {
1200
+ var reader = new jspb.BinaryReader(bytes);
1201
+ var msg = new proto.aggregator.ContractQueryCondition();
1202
+ return proto.aggregator.ContractQueryCondition.deserializeBinaryFromReader(msg, reader);
1203
+ };
1204
+ proto.aggregator.ContractQueryCondition.deserializeBinaryFromReader = function(msg, reader) {
1205
+ while (reader.nextField()) {
1206
+ if (reader.isEndGroup()) {
1207
+ break;
1208
+ }
1209
+ var field = reader.getFieldNumber();
1210
+ switch (field) {
1211
+ case 1:
1212
+ var value = (
1213
+ /** @type {string} */
1214
+ reader.readString()
1215
+ );
1216
+ msg.setContractAddress(value);
1217
+ break;
1218
+ case 2:
1219
+ var value = (
1220
+ /** @type {string} */
1221
+ reader.readString()
1222
+ );
1223
+ msg.setCallmsg(value);
1224
+ break;
1225
+ default:
1226
+ reader.skipField();
1227
+ break;
1228
+ }
1229
+ }
1230
+ return msg;
1231
+ };
1232
+ proto.aggregator.ContractQueryCondition.prototype.serializeBinary = function() {
1233
+ var writer = new jspb.BinaryWriter();
1234
+ proto.aggregator.ContractQueryCondition.serializeBinaryToWriter(this, writer);
1235
+ return writer.getResultBuffer();
1236
+ };
1237
+ proto.aggregator.ContractQueryCondition.serializeBinaryToWriter = function(message, writer) {
1238
+ var f = void 0;
1239
+ f = message.getContractAddress();
1240
+ if (f.length > 0) {
1241
+ writer.writeString(
1242
+ 1,
1243
+ f
1244
+ );
1245
+ }
1246
+ f = message.getCallmsg();
1247
+ if (f.length > 0) {
1248
+ writer.writeString(
1249
+ 2,
1250
+ f
1251
+ );
1252
+ }
1253
+ };
1254
+ proto.aggregator.ContractQueryCondition.prototype.getContractAddress = function() {
1255
+ return (
1256
+ /** @type {string} */
1257
+ jspb.Message.getFieldWithDefault(this, 1, "")
1258
+ );
1259
+ };
1260
+ proto.aggregator.ContractQueryCondition.prototype.setContractAddress = function(value) {
1261
+ return jspb.Message.setProto3StringField(this, 1, value);
1262
+ };
1263
+ proto.aggregator.ContractQueryCondition.prototype.getCallmsg = function() {
1264
+ return (
1265
+ /** @type {string} */
1266
+ jspb.Message.getFieldWithDefault(this, 2, "")
1267
+ );
1268
+ };
1269
+ proto.aggregator.ContractQueryCondition.prototype.setCallmsg = function(value) {
1270
+ return jspb.Message.setProto3StringField(this, 2, value);
1271
+ };
1272
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1273
+ proto.aggregator.ExpressionCondition.prototype.toObject = function(opt_includeInstance) {
1274
+ return proto.aggregator.ExpressionCondition.toObject(opt_includeInstance, this);
1275
+ };
1276
+ proto.aggregator.ExpressionCondition.toObject = function(includeInstance, msg) {
1277
+ var f, obj = {
1278
+ expression: jspb.Message.getFieldWithDefault(msg, 1, "")
1279
+ };
1280
+ if (includeInstance) {
1281
+ obj.$jspbMessageInstance = msg;
1282
+ }
1283
+ return obj;
1284
+ };
1285
+ }
1286
+ proto.aggregator.ExpressionCondition.deserializeBinary = function(bytes) {
1287
+ var reader = new jspb.BinaryReader(bytes);
1288
+ var msg = new proto.aggregator.ExpressionCondition();
1289
+ return proto.aggregator.ExpressionCondition.deserializeBinaryFromReader(msg, reader);
1290
+ };
1291
+ proto.aggregator.ExpressionCondition.deserializeBinaryFromReader = function(msg, reader) {
1292
+ while (reader.nextField()) {
1293
+ if (reader.isEndGroup()) {
1294
+ break;
1295
+ }
1296
+ var field = reader.getFieldNumber();
1297
+ switch (field) {
1298
+ case 1:
1299
+ var value = (
1300
+ /** @type {string} */
1301
+ reader.readString()
1302
+ );
1303
+ msg.setExpression(value);
1304
+ break;
1305
+ default:
1306
+ reader.skipField();
1307
+ break;
1308
+ }
1309
+ }
1310
+ return msg;
1311
+ };
1312
+ proto.aggregator.ExpressionCondition.prototype.serializeBinary = function() {
1313
+ var writer = new jspb.BinaryWriter();
1314
+ proto.aggregator.ExpressionCondition.serializeBinaryToWriter(this, writer);
1315
+ return writer.getResultBuffer();
1316
+ };
1317
+ proto.aggregator.ExpressionCondition.serializeBinaryToWriter = function(message, writer) {
1318
+ var f = void 0;
1319
+ f = message.getExpression();
1320
+ if (f.length > 0) {
1321
+ writer.writeString(
1322
+ 1,
1323
+ f
1324
+ );
1325
+ }
1326
+ };
1327
+ proto.aggregator.ExpressionCondition.prototype.getExpression = function() {
1328
+ return (
1329
+ /** @type {string} */
1330
+ jspb.Message.getFieldWithDefault(this, 1, "")
1331
+ );
1332
+ };
1333
+ proto.aggregator.ExpressionCondition.prototype.setExpression = function(value) {
1334
+ return jspb.Message.setProto3StringField(this, 1, value);
1335
+ };
1336
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1337
+ proto.aggregator.SyncTasksResp.prototype.toObject = function(opt_includeInstance) {
1338
+ return proto.aggregator.SyncTasksResp.toObject(opt_includeInstance, this);
1339
+ };
1340
+ proto.aggregator.SyncTasksResp.toObject = function(includeInstance, msg) {
1341
+ var f, obj = {
1342
+ id: jspb.Message.getFieldWithDefault(msg, 1, ""),
1343
+ checktype: jspb.Message.getFieldWithDefault(msg, 2, ""),
1344
+ trigger: (f = msg.getTrigger()) && proto.aggregator.TaskTrigger.toObject(includeInstance, f)
1345
+ };
1346
+ if (includeInstance) {
1347
+ obj.$jspbMessageInstance = msg;
1348
+ }
1349
+ return obj;
1350
+ };
1351
+ }
1352
+ proto.aggregator.SyncTasksResp.deserializeBinary = function(bytes) {
1353
+ var reader = new jspb.BinaryReader(bytes);
1354
+ var msg = new proto.aggregator.SyncTasksResp();
1355
+ return proto.aggregator.SyncTasksResp.deserializeBinaryFromReader(msg, reader);
1356
+ };
1357
+ proto.aggregator.SyncTasksResp.deserializeBinaryFromReader = function(msg, reader) {
1358
+ while (reader.nextField()) {
1359
+ if (reader.isEndGroup()) {
1360
+ break;
1361
+ }
1362
+ var field = reader.getFieldNumber();
1363
+ switch (field) {
1364
+ case 1:
1365
+ var value = (
1366
+ /** @type {string} */
1367
+ reader.readString()
1368
+ );
1369
+ msg.setId(value);
1370
+ break;
1371
+ case 2:
1372
+ var value = (
1373
+ /** @type {string} */
1374
+ reader.readString()
1375
+ );
1376
+ msg.setChecktype(value);
1377
+ break;
1378
+ case 3:
1379
+ var value = new proto.aggregator.TaskTrigger();
1380
+ reader.readMessage(value, proto.aggregator.TaskTrigger.deserializeBinaryFromReader);
1381
+ msg.setTrigger(value);
1382
+ break;
1383
+ default:
1384
+ reader.skipField();
1385
+ break;
1386
+ }
1387
+ }
1388
+ return msg;
1389
+ };
1390
+ proto.aggregator.SyncTasksResp.prototype.serializeBinary = function() {
1391
+ var writer = new jspb.BinaryWriter();
1392
+ proto.aggregator.SyncTasksResp.serializeBinaryToWriter(this, writer);
1393
+ return writer.getResultBuffer();
1394
+ };
1395
+ proto.aggregator.SyncTasksResp.serializeBinaryToWriter = function(message, writer) {
1396
+ var f = void 0;
1397
+ f = message.getId();
1398
+ if (f.length > 0) {
1399
+ writer.writeString(
1400
+ 1,
1401
+ f
1402
+ );
1403
+ }
1404
+ f = message.getChecktype();
1405
+ if (f.length > 0) {
1406
+ writer.writeString(
1407
+ 2,
1408
+ f
1409
+ );
1410
+ }
1411
+ f = message.getTrigger();
1412
+ if (f != null) {
1413
+ writer.writeMessage(
1414
+ 3,
1415
+ f,
1416
+ proto.aggregator.TaskTrigger.serializeBinaryToWriter
1417
+ );
1418
+ }
1419
+ };
1420
+ proto.aggregator.SyncTasksResp.prototype.getId = function() {
1421
+ return (
1422
+ /** @type {string} */
1423
+ jspb.Message.getFieldWithDefault(this, 1, "")
1424
+ );
1425
+ };
1426
+ proto.aggregator.SyncTasksResp.prototype.setId = function(value) {
1427
+ return jspb.Message.setProto3StringField(this, 1, value);
1428
+ };
1429
+ proto.aggregator.SyncTasksResp.prototype.getChecktype = function() {
1430
+ return (
1431
+ /** @type {string} */
1432
+ jspb.Message.getFieldWithDefault(this, 2, "")
1433
+ );
1434
+ };
1435
+ proto.aggregator.SyncTasksResp.prototype.setChecktype = function(value) {
1436
+ return jspb.Message.setProto3StringField(this, 2, value);
1437
+ };
1438
+ proto.aggregator.SyncTasksResp.prototype.getTrigger = function() {
1439
+ return (
1440
+ /** @type{?proto.aggregator.TaskTrigger} */
1441
+ jspb.Message.getWrapperField(this, proto.aggregator.TaskTrigger, 3)
1442
+ );
1443
+ };
1444
+ proto.aggregator.SyncTasksResp.prototype.setTrigger = function(value) {
1445
+ return jspb.Message.setWrapperField(this, 3, value);
1446
+ };
1447
+ proto.aggregator.SyncTasksResp.prototype.clearTrigger = function() {
1448
+ return this.setTrigger(void 0);
1449
+ };
1450
+ proto.aggregator.SyncTasksResp.prototype.hasTrigger = function() {
1451
+ return jspb.Message.getField(this, 3) != null;
1452
+ };
1453
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1454
+ proto.aggregator.ETHTransfer.prototype.toObject = function(opt_includeInstance) {
1455
+ return proto.aggregator.ETHTransfer.toObject(opt_includeInstance, this);
1456
+ };
1457
+ proto.aggregator.ETHTransfer.toObject = function(includeInstance, msg) {
1458
+ var f, obj = {
1459
+ destination: jspb.Message.getFieldWithDefault(msg, 1, ""),
1460
+ amount: jspb.Message.getFieldWithDefault(msg, 2, "")
1461
+ };
1462
+ if (includeInstance) {
1463
+ obj.$jspbMessageInstance = msg;
1464
+ }
1465
+ return obj;
1466
+ };
1467
+ }
1468
+ proto.aggregator.ETHTransfer.deserializeBinary = function(bytes) {
1469
+ var reader = new jspb.BinaryReader(bytes);
1470
+ var msg = new proto.aggregator.ETHTransfer();
1471
+ return proto.aggregator.ETHTransfer.deserializeBinaryFromReader(msg, reader);
1472
+ };
1473
+ proto.aggregator.ETHTransfer.deserializeBinaryFromReader = function(msg, reader) {
1474
+ while (reader.nextField()) {
1475
+ if (reader.isEndGroup()) {
1476
+ break;
1477
+ }
1478
+ var field = reader.getFieldNumber();
1479
+ switch (field) {
1480
+ case 1:
1481
+ var value = (
1482
+ /** @type {string} */
1483
+ reader.readString()
1484
+ );
1485
+ msg.setDestination(value);
1486
+ break;
1487
+ case 2:
1488
+ var value = (
1489
+ /** @type {string} */
1490
+ reader.readString()
1491
+ );
1492
+ msg.setAmount(value);
1493
+ break;
1494
+ default:
1495
+ reader.skipField();
1496
+ break;
1497
+ }
1498
+ }
1499
+ return msg;
1500
+ };
1501
+ proto.aggregator.ETHTransfer.prototype.serializeBinary = function() {
1502
+ var writer = new jspb.BinaryWriter();
1503
+ proto.aggregator.ETHTransfer.serializeBinaryToWriter(this, writer);
1504
+ return writer.getResultBuffer();
1505
+ };
1506
+ proto.aggregator.ETHTransfer.serializeBinaryToWriter = function(message, writer) {
1507
+ var f = void 0;
1508
+ f = message.getDestination();
1509
+ if (f.length > 0) {
1510
+ writer.writeString(
1511
+ 1,
1512
+ f
1513
+ );
1514
+ }
1515
+ f = message.getAmount();
1516
+ if (f.length > 0) {
1517
+ writer.writeString(
1518
+ 2,
1519
+ f
1520
+ );
1521
+ }
1522
+ };
1523
+ proto.aggregator.ETHTransfer.prototype.getDestination = function() {
1524
+ return (
1525
+ /** @type {string} */
1526
+ jspb.Message.getFieldWithDefault(this, 1, "")
1527
+ );
1528
+ };
1529
+ proto.aggregator.ETHTransfer.prototype.setDestination = function(value) {
1530
+ return jspb.Message.setProto3StringField(this, 1, value);
1531
+ };
1532
+ proto.aggregator.ETHTransfer.prototype.getAmount = function() {
1533
+ return (
1534
+ /** @type {string} */
1535
+ jspb.Message.getFieldWithDefault(this, 2, "")
1536
+ );
1537
+ };
1538
+ proto.aggregator.ETHTransfer.prototype.setAmount = function(value) {
1539
+ return jspb.Message.setProto3StringField(this, 2, value);
1540
+ };
1541
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1542
+ proto.aggregator.ContractExecution.prototype.toObject = function(opt_includeInstance) {
1543
+ return proto.aggregator.ContractExecution.toObject(opt_includeInstance, this);
1544
+ };
1545
+ proto.aggregator.ContractExecution.toObject = function(includeInstance, msg) {
1546
+ var f, obj = {
1547
+ contractAddress: jspb.Message.getFieldWithDefault(msg, 1, ""),
1548
+ callData: jspb.Message.getFieldWithDefault(msg, 2, ""),
1549
+ method: jspb.Message.getFieldWithDefault(msg, 3, ""),
1550
+ encodedParams: jspb.Message.getFieldWithDefault(msg, 4, "")
1551
+ };
1552
+ if (includeInstance) {
1553
+ obj.$jspbMessageInstance = msg;
1554
+ }
1555
+ return obj;
1556
+ };
1557
+ }
1558
+ proto.aggregator.ContractExecution.deserializeBinary = function(bytes) {
1559
+ var reader = new jspb.BinaryReader(bytes);
1560
+ var msg = new proto.aggregator.ContractExecution();
1561
+ return proto.aggregator.ContractExecution.deserializeBinaryFromReader(msg, reader);
1562
+ };
1563
+ proto.aggregator.ContractExecution.deserializeBinaryFromReader = function(msg, reader) {
1564
+ while (reader.nextField()) {
1565
+ if (reader.isEndGroup()) {
1566
+ break;
1567
+ }
1568
+ var field = reader.getFieldNumber();
1569
+ switch (field) {
1570
+ case 1:
1571
+ var value = (
1572
+ /** @type {string} */
1573
+ reader.readString()
1574
+ );
1575
+ msg.setContractAddress(value);
1576
+ break;
1577
+ case 2:
1578
+ var value = (
1579
+ /** @type {string} */
1580
+ reader.readString()
1581
+ );
1582
+ msg.setCallData(value);
1583
+ break;
1584
+ case 3:
1585
+ var value = (
1586
+ /** @type {string} */
1587
+ reader.readString()
1588
+ );
1589
+ msg.setMethod(value);
1590
+ break;
1591
+ case 4:
1592
+ var value = (
1593
+ /** @type {string} */
1594
+ reader.readString()
1595
+ );
1596
+ msg.setEncodedParams(value);
1597
+ break;
1598
+ default:
1599
+ reader.skipField();
1600
+ break;
1601
+ }
1602
+ }
1603
+ return msg;
1604
+ };
1605
+ proto.aggregator.ContractExecution.prototype.serializeBinary = function() {
1606
+ var writer = new jspb.BinaryWriter();
1607
+ proto.aggregator.ContractExecution.serializeBinaryToWriter(this, writer);
1608
+ return writer.getResultBuffer();
1609
+ };
1610
+ proto.aggregator.ContractExecution.serializeBinaryToWriter = function(message, writer) {
1611
+ var f = void 0;
1612
+ f = message.getContractAddress();
1613
+ if (f.length > 0) {
1614
+ writer.writeString(
1615
+ 1,
1616
+ f
1617
+ );
1618
+ }
1619
+ f = message.getCallData();
1620
+ if (f.length > 0) {
1621
+ writer.writeString(
1622
+ 2,
1623
+ f
1624
+ );
1625
+ }
1626
+ f = message.getMethod();
1627
+ if (f.length > 0) {
1628
+ writer.writeString(
1629
+ 3,
1630
+ f
1631
+ );
1632
+ }
1633
+ f = message.getEncodedParams();
1634
+ if (f.length > 0) {
1635
+ writer.writeString(
1636
+ 4,
1637
+ f
1638
+ );
1639
+ }
1640
+ };
1641
+ proto.aggregator.ContractExecution.prototype.getContractAddress = function() {
1642
+ return (
1643
+ /** @type {string} */
1644
+ jspb.Message.getFieldWithDefault(this, 1, "")
1645
+ );
1646
+ };
1647
+ proto.aggregator.ContractExecution.prototype.setContractAddress = function(value) {
1648
+ return jspb.Message.setProto3StringField(this, 1, value);
1649
+ };
1650
+ proto.aggregator.ContractExecution.prototype.getCallData = function() {
1651
+ return (
1652
+ /** @type {string} */
1653
+ jspb.Message.getFieldWithDefault(this, 2, "")
1654
+ );
1655
+ };
1656
+ proto.aggregator.ContractExecution.prototype.setCallData = function(value) {
1657
+ return jspb.Message.setProto3StringField(this, 2, value);
1658
+ };
1659
+ proto.aggregator.ContractExecution.prototype.getMethod = function() {
1660
+ return (
1661
+ /** @type {string} */
1662
+ jspb.Message.getFieldWithDefault(this, 3, "")
1663
+ );
1664
+ };
1665
+ proto.aggregator.ContractExecution.prototype.setMethod = function(value) {
1666
+ return jspb.Message.setProto3StringField(this, 3, value);
1667
+ };
1668
+ proto.aggregator.ContractExecution.prototype.getEncodedParams = function() {
1669
+ return (
1670
+ /** @type {string} */
1671
+ jspb.Message.getFieldWithDefault(this, 4, "")
1672
+ );
1673
+ };
1674
+ proto.aggregator.ContractExecution.prototype.setEncodedParams = function(value) {
1675
+ return jspb.Message.setProto3StringField(this, 4, value);
1676
+ };
1677
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1678
+ proto.aggregator.GraphQLDataQuery.prototype.toObject = function(opt_includeInstance) {
1679
+ return proto.aggregator.GraphQLDataQuery.toObject(opt_includeInstance, this);
1680
+ };
1681
+ proto.aggregator.GraphQLDataQuery.toObject = function(includeInstance, msg) {
1682
+ var f, obj = {
1683
+ url: jspb.Message.getFieldWithDefault(msg, 1, ""),
1684
+ query: jspb.Message.getFieldWithDefault(msg, 2, "")
1685
+ };
1686
+ if (includeInstance) {
1687
+ obj.$jspbMessageInstance = msg;
1688
+ }
1689
+ return obj;
1690
+ };
1691
+ }
1692
+ proto.aggregator.GraphQLDataQuery.deserializeBinary = function(bytes) {
1693
+ var reader = new jspb.BinaryReader(bytes);
1694
+ var msg = new proto.aggregator.GraphQLDataQuery();
1695
+ return proto.aggregator.GraphQLDataQuery.deserializeBinaryFromReader(msg, reader);
1696
+ };
1697
+ proto.aggregator.GraphQLDataQuery.deserializeBinaryFromReader = function(msg, reader) {
1698
+ while (reader.nextField()) {
1699
+ if (reader.isEndGroup()) {
1700
+ break;
1701
+ }
1702
+ var field = reader.getFieldNumber();
1703
+ switch (field) {
1704
+ case 1:
1705
+ var value = (
1706
+ /** @type {string} */
1707
+ reader.readString()
1708
+ );
1709
+ msg.setUrl(value);
1710
+ break;
1711
+ case 2:
1712
+ var value = (
1713
+ /** @type {string} */
1714
+ reader.readString()
1715
+ );
1716
+ msg.setQuery(value);
1717
+ break;
1718
+ default:
1719
+ reader.skipField();
1720
+ break;
1721
+ }
1722
+ }
1723
+ return msg;
1724
+ };
1725
+ proto.aggregator.GraphQLDataQuery.prototype.serializeBinary = function() {
1726
+ var writer = new jspb.BinaryWriter();
1727
+ proto.aggregator.GraphQLDataQuery.serializeBinaryToWriter(this, writer);
1728
+ return writer.getResultBuffer();
1729
+ };
1730
+ proto.aggregator.GraphQLDataQuery.serializeBinaryToWriter = function(message, writer) {
1731
+ var f = void 0;
1732
+ f = message.getUrl();
1733
+ if (f.length > 0) {
1734
+ writer.writeString(
1735
+ 1,
1736
+ f
1737
+ );
1738
+ }
1739
+ f = message.getQuery();
1740
+ if (f.length > 0) {
1741
+ writer.writeString(
1742
+ 2,
1743
+ f
1744
+ );
1745
+ }
1746
+ };
1747
+ proto.aggregator.GraphQLDataQuery.prototype.getUrl = function() {
1748
+ return (
1749
+ /** @type {string} */
1750
+ jspb.Message.getFieldWithDefault(this, 1, "")
1751
+ );
1752
+ };
1753
+ proto.aggregator.GraphQLDataQuery.prototype.setUrl = function(value) {
1754
+ return jspb.Message.setProto3StringField(this, 1, value);
1755
+ };
1756
+ proto.aggregator.GraphQLDataQuery.prototype.getQuery = function() {
1757
+ return (
1758
+ /** @type {string} */
1759
+ jspb.Message.getFieldWithDefault(this, 2, "")
1760
+ );
1761
+ };
1762
+ proto.aggregator.GraphQLDataQuery.prototype.setQuery = function(value) {
1763
+ return jspb.Message.setProto3StringField(this, 2, value);
1764
+ };
1765
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1766
+ proto.aggregator.HTTPAPICall.prototype.toObject = function(opt_includeInstance) {
1767
+ return proto.aggregator.HTTPAPICall.toObject(opt_includeInstance, this);
1768
+ };
1769
+ proto.aggregator.HTTPAPICall.toObject = function(includeInstance, msg) {
1770
+ var f, obj = {
1771
+ url: jspb.Message.getFieldWithDefault(msg, 1, ""),
1772
+ headersMap: (f = msg.getHeadersMap()) ? f.toObject(includeInstance, void 0) : [],
1773
+ body: jspb.Message.getFieldWithDefault(msg, 3, "")
1774
+ };
1775
+ if (includeInstance) {
1776
+ obj.$jspbMessageInstance = msg;
1777
+ }
1778
+ return obj;
1779
+ };
1780
+ }
1781
+ proto.aggregator.HTTPAPICall.deserializeBinary = function(bytes) {
1782
+ var reader = new jspb.BinaryReader(bytes);
1783
+ var msg = new proto.aggregator.HTTPAPICall();
1784
+ return proto.aggregator.HTTPAPICall.deserializeBinaryFromReader(msg, reader);
1785
+ };
1786
+ proto.aggregator.HTTPAPICall.deserializeBinaryFromReader = function(msg, reader) {
1787
+ while (reader.nextField()) {
1788
+ if (reader.isEndGroup()) {
1789
+ break;
1790
+ }
1791
+ var field = reader.getFieldNumber();
1792
+ switch (field) {
1793
+ case 1:
1794
+ var value = (
1795
+ /** @type {string} */
1796
+ reader.readString()
1797
+ );
1798
+ msg.setUrl(value);
1799
+ break;
1800
+ case 2:
1801
+ var value = msg.getHeadersMap();
1802
+ reader.readMessage(value, function(message, reader2) {
1803
+ jspb.Map.deserializeBinary(message, reader2, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", "");
1804
+ });
1805
+ break;
1806
+ case 3:
1807
+ var value = (
1808
+ /** @type {string} */
1809
+ reader.readString()
1810
+ );
1811
+ msg.setBody(value);
1812
+ break;
1813
+ default:
1814
+ reader.skipField();
1815
+ break;
1816
+ }
1817
+ }
1818
+ return msg;
1819
+ };
1820
+ proto.aggregator.HTTPAPICall.prototype.serializeBinary = function() {
1821
+ var writer = new jspb.BinaryWriter();
1822
+ proto.aggregator.HTTPAPICall.serializeBinaryToWriter(this, writer);
1823
+ return writer.getResultBuffer();
1824
+ };
1825
+ proto.aggregator.HTTPAPICall.serializeBinaryToWriter = function(message, writer) {
1826
+ var f = void 0;
1827
+ f = message.getUrl();
1828
+ if (f.length > 0) {
1829
+ writer.writeString(
1830
+ 1,
1831
+ f
1832
+ );
1833
+ }
1834
+ f = message.getHeadersMap(true);
1835
+ if (f && f.getLength() > 0) {
1836
+ f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString);
1837
+ }
1838
+ f = message.getBody();
1839
+ if (f.length > 0) {
1840
+ writer.writeString(
1841
+ 3,
1842
+ f
1843
+ );
1844
+ }
1845
+ };
1846
+ proto.aggregator.HTTPAPICall.prototype.getUrl = function() {
1847
+ return (
1848
+ /** @type {string} */
1849
+ jspb.Message.getFieldWithDefault(this, 1, "")
1850
+ );
1851
+ };
1852
+ proto.aggregator.HTTPAPICall.prototype.setUrl = function(value) {
1853
+ return jspb.Message.setProto3StringField(this, 1, value);
1854
+ };
1855
+ proto.aggregator.HTTPAPICall.prototype.getHeadersMap = function(opt_noLazyCreate) {
1856
+ return (
1857
+ /** @type {!jspb.Map<string,string>} */
1858
+ jspb.Message.getMapField(
1859
+ this,
1860
+ 2,
1861
+ opt_noLazyCreate,
1862
+ null
1863
+ )
1864
+ );
1865
+ };
1866
+ proto.aggregator.HTTPAPICall.prototype.clearHeadersMap = function() {
1867
+ this.getHeadersMap().clear();
1868
+ return this;
1869
+ };
1870
+ proto.aggregator.HTTPAPICall.prototype.getBody = function() {
1871
+ return (
1872
+ /** @type {string} */
1873
+ jspb.Message.getFieldWithDefault(this, 3, "")
1874
+ );
1875
+ };
1876
+ proto.aggregator.HTTPAPICall.prototype.setBody = function(value) {
1877
+ return jspb.Message.setProto3StringField(this, 3, value);
1878
+ };
1879
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1880
+ proto.aggregator.CustomCode.prototype.toObject = function(opt_includeInstance) {
1881
+ return proto.aggregator.CustomCode.toObject(opt_includeInstance, this);
1882
+ };
1883
+ proto.aggregator.CustomCode.toObject = function(includeInstance, msg) {
1884
+ var f, obj = {
1885
+ type: jspb.Message.getFieldWithDefault(msg, 1, 0),
1886
+ body: jspb.Message.getFieldWithDefault(msg, 2, "")
1887
+ };
1888
+ if (includeInstance) {
1889
+ obj.$jspbMessageInstance = msg;
1890
+ }
1891
+ return obj;
1892
+ };
1893
+ }
1894
+ proto.aggregator.CustomCode.deserializeBinary = function(bytes) {
1895
+ var reader = new jspb.BinaryReader(bytes);
1896
+ var msg = new proto.aggregator.CustomCode();
1897
+ return proto.aggregator.CustomCode.deserializeBinaryFromReader(msg, reader);
1898
+ };
1899
+ proto.aggregator.CustomCode.deserializeBinaryFromReader = function(msg, reader) {
1900
+ while (reader.nextField()) {
1901
+ if (reader.isEndGroup()) {
1902
+ break;
1903
+ }
1904
+ var field = reader.getFieldNumber();
1905
+ switch (field) {
1906
+ case 1:
1907
+ var value = (
1908
+ /** @type {!proto.aggregator.CustomCodeType} */
1909
+ reader.readEnum()
1910
+ );
1911
+ msg.setType(value);
1912
+ break;
1913
+ case 2:
1914
+ var value = (
1915
+ /** @type {string} */
1916
+ reader.readString()
1917
+ );
1918
+ msg.setBody(value);
1919
+ break;
1920
+ default:
1921
+ reader.skipField();
1922
+ break;
1923
+ }
1924
+ }
1925
+ return msg;
1926
+ };
1927
+ proto.aggregator.CustomCode.prototype.serializeBinary = function() {
1928
+ var writer = new jspb.BinaryWriter();
1929
+ proto.aggregator.CustomCode.serializeBinaryToWriter(this, writer);
1930
+ return writer.getResultBuffer();
1931
+ };
1932
+ proto.aggregator.CustomCode.serializeBinaryToWriter = function(message, writer) {
1933
+ var f = void 0;
1934
+ f = message.getType();
1935
+ if (f !== 0) {
1936
+ writer.writeEnum(
1937
+ 1,
1938
+ f
1939
+ );
1940
+ }
1941
+ f = message.getBody();
1942
+ if (f.length > 0) {
1943
+ writer.writeString(
1944
+ 2,
1945
+ f
1946
+ );
1947
+ }
1948
+ };
1949
+ proto.aggregator.CustomCode.prototype.getType = function() {
1950
+ return (
1951
+ /** @type {!proto.aggregator.CustomCodeType} */
1952
+ jspb.Message.getFieldWithDefault(this, 1, 0)
1953
+ );
1954
+ };
1955
+ proto.aggregator.CustomCode.prototype.setType = function(value) {
1956
+ return jspb.Message.setProto3EnumField(this, 1, value);
1957
+ };
1958
+ proto.aggregator.CustomCode.prototype.getBody = function() {
1959
+ return (
1960
+ /** @type {string} */
1961
+ jspb.Message.getFieldWithDefault(this, 2, "")
1962
+ );
1963
+ };
1964
+ proto.aggregator.CustomCode.prototype.setBody = function(value) {
1965
+ return jspb.Message.setProto3StringField(this, 2, value);
1966
+ };
1967
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1968
+ proto.aggregator.ConditionJump.prototype.toObject = function(opt_includeInstance) {
1969
+ return proto.aggregator.ConditionJump.toObject(opt_includeInstance, this);
1970
+ };
1971
+ proto.aggregator.ConditionJump.toObject = function(includeInstance, msg) {
1972
+ var f, obj = {
1973
+ expression: jspb.Message.getFieldWithDefault(msg, 1, ""),
1974
+ next: jspb.Message.getFieldWithDefault(msg, 2, "")
1975
+ };
1976
+ if (includeInstance) {
1977
+ obj.$jspbMessageInstance = msg;
1978
+ }
1979
+ return obj;
1980
+ };
1981
+ }
1982
+ proto.aggregator.ConditionJump.deserializeBinary = function(bytes) {
1983
+ var reader = new jspb.BinaryReader(bytes);
1984
+ var msg = new proto.aggregator.ConditionJump();
1985
+ return proto.aggregator.ConditionJump.deserializeBinaryFromReader(msg, reader);
1986
+ };
1987
+ proto.aggregator.ConditionJump.deserializeBinaryFromReader = function(msg, reader) {
1988
+ while (reader.nextField()) {
1989
+ if (reader.isEndGroup()) {
1990
+ break;
1991
+ }
1992
+ var field = reader.getFieldNumber();
1993
+ switch (field) {
1994
+ case 1:
1995
+ var value = (
1996
+ /** @type {string} */
1997
+ reader.readString()
1998
+ );
1999
+ msg.setExpression(value);
2000
+ break;
2001
+ case 2:
2002
+ var value = (
2003
+ /** @type {string} */
2004
+ reader.readString()
2005
+ );
2006
+ msg.setNext(value);
2007
+ break;
2008
+ default:
2009
+ reader.skipField();
2010
+ break;
2011
+ }
2012
+ }
2013
+ return msg;
2014
+ };
2015
+ proto.aggregator.ConditionJump.prototype.serializeBinary = function() {
2016
+ var writer = new jspb.BinaryWriter();
2017
+ proto.aggregator.ConditionJump.serializeBinaryToWriter(this, writer);
2018
+ return writer.getResultBuffer();
2019
+ };
2020
+ proto.aggregator.ConditionJump.serializeBinaryToWriter = function(message, writer) {
2021
+ var f = void 0;
2022
+ f = message.getExpression();
2023
+ if (f.length > 0) {
2024
+ writer.writeString(
2025
+ 1,
2026
+ f
2027
+ );
2028
+ }
2029
+ f = message.getNext();
2030
+ if (f.length > 0) {
2031
+ writer.writeString(
2032
+ 2,
2033
+ f
2034
+ );
2035
+ }
2036
+ };
2037
+ proto.aggregator.ConditionJump.prototype.getExpression = function() {
2038
+ return (
2039
+ /** @type {string} */
2040
+ jspb.Message.getFieldWithDefault(this, 1, "")
2041
+ );
2042
+ };
2043
+ proto.aggregator.ConditionJump.prototype.setExpression = function(value) {
2044
+ return jspb.Message.setProto3StringField(this, 1, value);
2045
+ };
2046
+ proto.aggregator.ConditionJump.prototype.getNext = function() {
2047
+ return (
2048
+ /** @type {string} */
2049
+ jspb.Message.getFieldWithDefault(this, 2, "")
2050
+ );
2051
+ };
2052
+ proto.aggregator.ConditionJump.prototype.setNext = function(value) {
2053
+ return jspb.Message.setProto3StringField(this, 2, value);
2054
+ };
2055
+ proto.aggregator.BranchAction.repeatedFields_ = [2];
2056
+ if (jspb.Message.GENERATE_TO_OBJECT) {
2057
+ proto.aggregator.BranchAction.prototype.toObject = function(opt_includeInstance) {
2058
+ return proto.aggregator.BranchAction.toObject(opt_includeInstance, this);
2059
+ };
2060
+ proto.aggregator.BranchAction.toObject = function(includeInstance, msg) {
2061
+ var f, obj = {
2062
+ pb_if: (f = msg.getIf()) && proto.aggregator.ConditionJump.toObject(includeInstance, f),
2063
+ elseifsList: jspb.Message.toObjectList(
2064
+ msg.getElseifsList(),
2065
+ proto.aggregator.ConditionJump.toObject,
2066
+ includeInstance
2067
+ ),
2068
+ pb_else: (f = msg.getElse()) && proto.aggregator.ConditionJump.toObject(includeInstance, f)
2069
+ };
2070
+ if (includeInstance) {
2071
+ obj.$jspbMessageInstance = msg;
2072
+ }
2073
+ return obj;
2074
+ };
2075
+ }
2076
+ proto.aggregator.BranchAction.deserializeBinary = function(bytes) {
2077
+ var reader = new jspb.BinaryReader(bytes);
2078
+ var msg = new proto.aggregator.BranchAction();
2079
+ return proto.aggregator.BranchAction.deserializeBinaryFromReader(msg, reader);
2080
+ };
2081
+ proto.aggregator.BranchAction.deserializeBinaryFromReader = function(msg, reader) {
2082
+ while (reader.nextField()) {
2083
+ if (reader.isEndGroup()) {
2084
+ break;
2085
+ }
2086
+ var field = reader.getFieldNumber();
2087
+ switch (field) {
2088
+ case 1:
2089
+ var value = new proto.aggregator.ConditionJump();
2090
+ reader.readMessage(value, proto.aggregator.ConditionJump.deserializeBinaryFromReader);
2091
+ msg.setIf(value);
2092
+ break;
2093
+ case 2:
2094
+ var value = new proto.aggregator.ConditionJump();
2095
+ reader.readMessage(value, proto.aggregator.ConditionJump.deserializeBinaryFromReader);
2096
+ msg.addElseifs(value);
2097
+ break;
2098
+ case 3:
2099
+ var value = new proto.aggregator.ConditionJump();
2100
+ reader.readMessage(value, proto.aggregator.ConditionJump.deserializeBinaryFromReader);
2101
+ msg.setElse(value);
2102
+ break;
2103
+ default:
2104
+ reader.skipField();
2105
+ break;
2106
+ }
2107
+ }
2108
+ return msg;
2109
+ };
2110
+ proto.aggregator.BranchAction.prototype.serializeBinary = function() {
2111
+ var writer = new jspb.BinaryWriter();
2112
+ proto.aggregator.BranchAction.serializeBinaryToWriter(this, writer);
2113
+ return writer.getResultBuffer();
2114
+ };
2115
+ proto.aggregator.BranchAction.serializeBinaryToWriter = function(message, writer) {
2116
+ var f = void 0;
2117
+ f = message.getIf();
2118
+ if (f != null) {
2119
+ writer.writeMessage(
2120
+ 1,
2121
+ f,
2122
+ proto.aggregator.ConditionJump.serializeBinaryToWriter
2123
+ );
2124
+ }
2125
+ f = message.getElseifsList();
2126
+ if (f.length > 0) {
2127
+ writer.writeRepeatedMessage(
2128
+ 2,
2129
+ f,
2130
+ proto.aggregator.ConditionJump.serializeBinaryToWriter
2131
+ );
2132
+ }
2133
+ f = message.getElse();
2134
+ if (f != null) {
2135
+ writer.writeMessage(
2136
+ 3,
2137
+ f,
2138
+ proto.aggregator.ConditionJump.serializeBinaryToWriter
2139
+ );
2140
+ }
2141
+ };
2142
+ proto.aggregator.BranchAction.prototype.getIf = function() {
2143
+ return (
2144
+ /** @type{?proto.aggregator.ConditionJump} */
2145
+ jspb.Message.getWrapperField(this, proto.aggregator.ConditionJump, 1)
2146
+ );
2147
+ };
2148
+ proto.aggregator.BranchAction.prototype.setIf = function(value) {
2149
+ return jspb.Message.setWrapperField(this, 1, value);
2150
+ };
2151
+ proto.aggregator.BranchAction.prototype.clearIf = function() {
2152
+ return this.setIf(void 0);
2153
+ };
2154
+ proto.aggregator.BranchAction.prototype.hasIf = function() {
2155
+ return jspb.Message.getField(this, 1) != null;
2156
+ };
2157
+ proto.aggregator.BranchAction.prototype.getElseifsList = function() {
2158
+ return (
2159
+ /** @type{!Array<!proto.aggregator.ConditionJump>} */
2160
+ jspb.Message.getRepeatedWrapperField(this, proto.aggregator.ConditionJump, 2)
2161
+ );
2162
+ };
2163
+ proto.aggregator.BranchAction.prototype.setElseifsList = function(value) {
2164
+ return jspb.Message.setRepeatedWrapperField(this, 2, value);
2165
+ };
2166
+ proto.aggregator.BranchAction.prototype.addElseifs = function(opt_value, opt_index) {
2167
+ return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.aggregator.ConditionJump, opt_index);
2168
+ };
2169
+ proto.aggregator.BranchAction.prototype.clearElseifsList = function() {
2170
+ return this.setElseifsList([]);
2171
+ };
2172
+ proto.aggregator.BranchAction.prototype.getElse = function() {
2173
+ return (
2174
+ /** @type{?proto.aggregator.ConditionJump} */
2175
+ jspb.Message.getWrapperField(this, proto.aggregator.ConditionJump, 3)
2176
+ );
2177
+ };
2178
+ proto.aggregator.BranchAction.prototype.setElse = function(value) {
2179
+ return jspb.Message.setWrapperField(this, 3, value);
2180
+ };
2181
+ proto.aggregator.BranchAction.prototype.clearElse = function() {
2182
+ return this.setElse(void 0);
2183
+ };
2184
+ proto.aggregator.BranchAction.prototype.hasElse = function() {
2185
+ return jspb.Message.getField(this, 3) != null;
2186
+ };
2187
+ proto.aggregator.TaskAction.repeatedFields_ = [4];
2188
+ if (jspb.Message.GENERATE_TO_OBJECT) {
2189
+ proto.aggregator.TaskAction.prototype.toObject = function(opt_includeInstance) {
2190
+ return proto.aggregator.TaskAction.toObject(opt_includeInstance, this);
2191
+ };
2192
+ proto.aggregator.TaskAction.toObject = function(includeInstance, msg) {
2193
+ var f, obj = {
2194
+ taskType: jspb.Message.getFieldWithDefault(msg, 1, 0),
2195
+ id: jspb.Message.getFieldWithDefault(msg, 2, ""),
2196
+ name: jspb.Message.getFieldWithDefault(msg, 3, ""),
2197
+ nextList: (f = jspb.Message.getRepeatedField(msg, 4)) == null ? void 0 : f,
2198
+ ethTransfer: (f = msg.getEthTransfer()) && proto.aggregator.ETHTransfer.toObject(includeInstance, f),
2199
+ contractExecution: (f = msg.getContractExecution()) && proto.aggregator.ContractExecution.toObject(includeInstance, f),
2200
+ graphqlDataQuery: (f = msg.getGraphqlDataQuery()) && proto.aggregator.GraphQLDataQuery.toObject(includeInstance, f),
2201
+ httpDataQuery: (f = msg.getHttpDataQuery()) && proto.aggregator.HTTPAPICall.toObject(includeInstance, f),
2202
+ customCode: (f = msg.getCustomCode()) && proto.aggregator.CustomCode.toObject(includeInstance, f),
2203
+ branch: (f = msg.getBranch()) && proto.aggregator.BranchAction.toObject(includeInstance, f)
2204
+ };
2205
+ if (includeInstance) {
2206
+ obj.$jspbMessageInstance = msg;
2207
+ }
2208
+ return obj;
2209
+ };
2210
+ }
2211
+ proto.aggregator.TaskAction.deserializeBinary = function(bytes) {
2212
+ var reader = new jspb.BinaryReader(bytes);
2213
+ var msg = new proto.aggregator.TaskAction();
2214
+ return proto.aggregator.TaskAction.deserializeBinaryFromReader(msg, reader);
2215
+ };
2216
+ proto.aggregator.TaskAction.deserializeBinaryFromReader = function(msg, reader) {
2217
+ while (reader.nextField()) {
2218
+ if (reader.isEndGroup()) {
2219
+ break;
2220
+ }
2221
+ var field = reader.getFieldNumber();
2222
+ switch (field) {
2223
+ case 1:
2224
+ var value = (
2225
+ /** @type {!proto.aggregator.TaskType} */
2226
+ reader.readEnum()
2227
+ );
2228
+ msg.setTaskType(value);
2229
+ break;
2230
+ case 2:
2231
+ var value = (
2232
+ /** @type {string} */
2233
+ reader.readString()
2234
+ );
2235
+ msg.setId(value);
2236
+ break;
2237
+ case 3:
2238
+ var value = (
2239
+ /** @type {string} */
2240
+ reader.readString()
2241
+ );
2242
+ msg.setName(value);
2243
+ break;
2244
+ case 4:
2245
+ var value = (
2246
+ /** @type {string} */
2247
+ reader.readString()
2248
+ );
2249
+ msg.addNext(value);
2250
+ break;
2251
+ case 10:
2252
+ var value = new proto.aggregator.ETHTransfer();
2253
+ reader.readMessage(value, proto.aggregator.ETHTransfer.deserializeBinaryFromReader);
2254
+ msg.setEthTransfer(value);
2255
+ break;
2256
+ case 11:
2257
+ var value = new proto.aggregator.ContractExecution();
2258
+ reader.readMessage(value, proto.aggregator.ContractExecution.deserializeBinaryFromReader);
2259
+ msg.setContractExecution(value);
2260
+ break;
2261
+ case 12:
2262
+ var value = new proto.aggregator.GraphQLDataQuery();
2263
+ reader.readMessage(value, proto.aggregator.GraphQLDataQuery.deserializeBinaryFromReader);
2264
+ msg.setGraphqlDataQuery(value);
2265
+ break;
2266
+ case 13:
2267
+ var value = new proto.aggregator.HTTPAPICall();
2268
+ reader.readMessage(value, proto.aggregator.HTTPAPICall.deserializeBinaryFromReader);
2269
+ msg.setHttpDataQuery(value);
2270
+ break;
2271
+ case 14:
2272
+ var value = new proto.aggregator.CustomCode();
2273
+ reader.readMessage(value, proto.aggregator.CustomCode.deserializeBinaryFromReader);
2274
+ msg.setCustomCode(value);
2275
+ break;
2276
+ case 15:
2277
+ var value = new proto.aggregator.BranchAction();
2278
+ reader.readMessage(value, proto.aggregator.BranchAction.deserializeBinaryFromReader);
2279
+ msg.setBranch(value);
2280
+ break;
2281
+ default:
2282
+ reader.skipField();
2283
+ break;
2284
+ }
2285
+ }
2286
+ return msg;
2287
+ };
2288
+ proto.aggregator.TaskAction.prototype.serializeBinary = function() {
2289
+ var writer = new jspb.BinaryWriter();
2290
+ proto.aggregator.TaskAction.serializeBinaryToWriter(this, writer);
2291
+ return writer.getResultBuffer();
2292
+ };
2293
+ proto.aggregator.TaskAction.serializeBinaryToWriter = function(message, writer) {
2294
+ var f = void 0;
2295
+ f = message.getTaskType();
2296
+ if (f !== 0) {
2297
+ writer.writeEnum(
2298
+ 1,
2299
+ f
2300
+ );
2301
+ }
2302
+ f = message.getId();
2303
+ if (f.length > 0) {
2304
+ writer.writeString(
2305
+ 2,
2306
+ f
2307
+ );
2308
+ }
2309
+ f = message.getName();
2310
+ if (f.length > 0) {
2311
+ writer.writeString(
2312
+ 3,
2313
+ f
2314
+ );
2315
+ }
2316
+ f = message.getNextList();
2317
+ if (f.length > 0) {
2318
+ writer.writeRepeatedString(
2319
+ 4,
2320
+ f
2321
+ );
2322
+ }
2323
+ f = message.getEthTransfer();
2324
+ if (f != null) {
2325
+ writer.writeMessage(
2326
+ 10,
2327
+ f,
2328
+ proto.aggregator.ETHTransfer.serializeBinaryToWriter
2329
+ );
2330
+ }
2331
+ f = message.getContractExecution();
2332
+ if (f != null) {
2333
+ writer.writeMessage(
2334
+ 11,
2335
+ f,
2336
+ proto.aggregator.ContractExecution.serializeBinaryToWriter
2337
+ );
2338
+ }
2339
+ f = message.getGraphqlDataQuery();
2340
+ if (f != null) {
2341
+ writer.writeMessage(
2342
+ 12,
2343
+ f,
2344
+ proto.aggregator.GraphQLDataQuery.serializeBinaryToWriter
2345
+ );
2346
+ }
2347
+ f = message.getHttpDataQuery();
2348
+ if (f != null) {
2349
+ writer.writeMessage(
2350
+ 13,
2351
+ f,
2352
+ proto.aggregator.HTTPAPICall.serializeBinaryToWriter
2353
+ );
2354
+ }
2355
+ f = message.getCustomCode();
2356
+ if (f != null) {
2357
+ writer.writeMessage(
2358
+ 14,
2359
+ f,
2360
+ proto.aggregator.CustomCode.serializeBinaryToWriter
2361
+ );
2362
+ }
2363
+ f = message.getBranch();
2364
+ if (f != null) {
2365
+ writer.writeMessage(
2366
+ 15,
2367
+ f,
2368
+ proto.aggregator.BranchAction.serializeBinaryToWriter
2369
+ );
2370
+ }
2371
+ };
2372
+ proto.aggregator.TaskAction.prototype.getTaskType = function() {
2373
+ return (
2374
+ /** @type {!proto.aggregator.TaskType} */
2375
+ jspb.Message.getFieldWithDefault(this, 1, 0)
2376
+ );
2377
+ };
2378
+ proto.aggregator.TaskAction.prototype.setTaskType = function(value) {
2379
+ return jspb.Message.setProto3EnumField(this, 1, value);
2380
+ };
2381
+ proto.aggregator.TaskAction.prototype.getId = function() {
2382
+ return (
2383
+ /** @type {string} */
2384
+ jspb.Message.getFieldWithDefault(this, 2, "")
2385
+ );
2386
+ };
2387
+ proto.aggregator.TaskAction.prototype.setId = function(value) {
2388
+ return jspb.Message.setProto3StringField(this, 2, value);
2389
+ };
2390
+ proto.aggregator.TaskAction.prototype.getName = function() {
2391
+ return (
2392
+ /** @type {string} */
2393
+ jspb.Message.getFieldWithDefault(this, 3, "")
2394
+ );
2395
+ };
2396
+ proto.aggregator.TaskAction.prototype.setName = function(value) {
2397
+ return jspb.Message.setProto3StringField(this, 3, value);
2398
+ };
2399
+ proto.aggregator.TaskAction.prototype.getNextList = function() {
2400
+ return (
2401
+ /** @type {!Array<string>} */
2402
+ jspb.Message.getRepeatedField(this, 4)
2403
+ );
2404
+ };
2405
+ proto.aggregator.TaskAction.prototype.setNextList = function(value) {
2406
+ return jspb.Message.setField(this, 4, value || []);
2407
+ };
2408
+ proto.aggregator.TaskAction.prototype.addNext = function(value, opt_index) {
2409
+ return jspb.Message.addToRepeatedField(this, 4, value, opt_index);
2410
+ };
2411
+ proto.aggregator.TaskAction.prototype.clearNextList = function() {
2412
+ return this.setNextList([]);
2413
+ };
2414
+ proto.aggregator.TaskAction.prototype.getEthTransfer = function() {
2415
+ return (
2416
+ /** @type{?proto.aggregator.ETHTransfer} */
2417
+ jspb.Message.getWrapperField(this, proto.aggregator.ETHTransfer, 10)
2418
+ );
2419
+ };
2420
+ proto.aggregator.TaskAction.prototype.setEthTransfer = function(value) {
2421
+ return jspb.Message.setWrapperField(this, 10, value);
2422
+ };
2423
+ proto.aggregator.TaskAction.prototype.clearEthTransfer = function() {
2424
+ return this.setEthTransfer(void 0);
2425
+ };
2426
+ proto.aggregator.TaskAction.prototype.hasEthTransfer = function() {
2427
+ return jspb.Message.getField(this, 10) != null;
2428
+ };
2429
+ proto.aggregator.TaskAction.prototype.getContractExecution = function() {
2430
+ return (
2431
+ /** @type{?proto.aggregator.ContractExecution} */
2432
+ jspb.Message.getWrapperField(this, proto.aggregator.ContractExecution, 11)
2433
+ );
2434
+ };
2435
+ proto.aggregator.TaskAction.prototype.setContractExecution = function(value) {
2436
+ return jspb.Message.setWrapperField(this, 11, value);
2437
+ };
2438
+ proto.aggregator.TaskAction.prototype.clearContractExecution = function() {
2439
+ return this.setContractExecution(void 0);
2440
+ };
2441
+ proto.aggregator.TaskAction.prototype.hasContractExecution = function() {
2442
+ return jspb.Message.getField(this, 11) != null;
2443
+ };
2444
+ proto.aggregator.TaskAction.prototype.getGraphqlDataQuery = function() {
2445
+ return (
2446
+ /** @type{?proto.aggregator.GraphQLDataQuery} */
2447
+ jspb.Message.getWrapperField(this, proto.aggregator.GraphQLDataQuery, 12)
2448
+ );
2449
+ };
2450
+ proto.aggregator.TaskAction.prototype.setGraphqlDataQuery = function(value) {
2451
+ return jspb.Message.setWrapperField(this, 12, value);
2452
+ };
2453
+ proto.aggregator.TaskAction.prototype.clearGraphqlDataQuery = function() {
2454
+ return this.setGraphqlDataQuery(void 0);
2455
+ };
2456
+ proto.aggregator.TaskAction.prototype.hasGraphqlDataQuery = function() {
2457
+ return jspb.Message.getField(this, 12) != null;
2458
+ };
2459
+ proto.aggregator.TaskAction.prototype.getHttpDataQuery = function() {
2460
+ return (
2461
+ /** @type{?proto.aggregator.HTTPAPICall} */
2462
+ jspb.Message.getWrapperField(this, proto.aggregator.HTTPAPICall, 13)
2463
+ );
2464
+ };
2465
+ proto.aggregator.TaskAction.prototype.setHttpDataQuery = function(value) {
2466
+ return jspb.Message.setWrapperField(this, 13, value);
2467
+ };
2468
+ proto.aggregator.TaskAction.prototype.clearHttpDataQuery = function() {
2469
+ return this.setHttpDataQuery(void 0);
2470
+ };
2471
+ proto.aggregator.TaskAction.prototype.hasHttpDataQuery = function() {
2472
+ return jspb.Message.getField(this, 13) != null;
2473
+ };
2474
+ proto.aggregator.TaskAction.prototype.getCustomCode = function() {
2475
+ return (
2476
+ /** @type{?proto.aggregator.CustomCode} */
2477
+ jspb.Message.getWrapperField(this, proto.aggregator.CustomCode, 14)
2478
+ );
2479
+ };
2480
+ proto.aggregator.TaskAction.prototype.setCustomCode = function(value) {
2481
+ return jspb.Message.setWrapperField(this, 14, value);
2482
+ };
2483
+ proto.aggregator.TaskAction.prototype.clearCustomCode = function() {
2484
+ return this.setCustomCode(void 0);
2485
+ };
2486
+ proto.aggregator.TaskAction.prototype.hasCustomCode = function() {
2487
+ return jspb.Message.getField(this, 14) != null;
2488
+ };
2489
+ proto.aggregator.TaskAction.prototype.getBranch = function() {
2490
+ return (
2491
+ /** @type{?proto.aggregator.BranchAction} */
2492
+ jspb.Message.getWrapperField(this, proto.aggregator.BranchAction, 15)
2493
+ );
2494
+ };
2495
+ proto.aggregator.TaskAction.prototype.setBranch = function(value) {
2496
+ return jspb.Message.setWrapperField(this, 15, value);
2497
+ };
2498
+ proto.aggregator.TaskAction.prototype.clearBranch = function() {
2499
+ return this.setBranch(void 0);
2500
+ };
2501
+ proto.aggregator.TaskAction.prototype.hasBranch = function() {
2502
+ return jspb.Message.getField(this, 15) != null;
2503
+ };
2504
+ if (jspb.Message.GENERATE_TO_OBJECT) {
2505
+ proto.aggregator.Execution.prototype.toObject = function(opt_includeInstance) {
2506
+ return proto.aggregator.Execution.toObject(opt_includeInstance, this);
2507
+ };
2508
+ proto.aggregator.Execution.toObject = function(includeInstance, msg) {
2509
+ var f, obj = {
2510
+ epoch: jspb.Message.getFieldWithDefault(msg, 1, 0),
2511
+ userOpHash: jspb.Message.getFieldWithDefault(msg, 2, ""),
2512
+ error: jspb.Message.getFieldWithDefault(msg, 3, "")
2513
+ };
2514
+ if (includeInstance) {
2515
+ obj.$jspbMessageInstance = msg;
2516
+ }
2517
+ return obj;
2518
+ };
2519
+ }
2520
+ proto.aggregator.Execution.deserializeBinary = function(bytes) {
2521
+ var reader = new jspb.BinaryReader(bytes);
2522
+ var msg = new proto.aggregator.Execution();
2523
+ return proto.aggregator.Execution.deserializeBinaryFromReader(msg, reader);
2524
+ };
2525
+ proto.aggregator.Execution.deserializeBinaryFromReader = function(msg, reader) {
2526
+ while (reader.nextField()) {
2527
+ if (reader.isEndGroup()) {
2528
+ break;
2529
+ }
2530
+ var field = reader.getFieldNumber();
2531
+ switch (field) {
2532
+ case 1:
2533
+ var value = (
2534
+ /** @type {number} */
2535
+ reader.readInt64()
2536
+ );
2537
+ msg.setEpoch(value);
2538
+ break;
2539
+ case 2:
2540
+ var value = (
2541
+ /** @type {string} */
2542
+ reader.readString()
2543
+ );
2544
+ msg.setUserOpHash(value);
2545
+ break;
2546
+ case 3:
2547
+ var value = (
2548
+ /** @type {string} */
2549
+ reader.readString()
2550
+ );
2551
+ msg.setError(value);
2552
+ break;
2553
+ default:
2554
+ reader.skipField();
2555
+ break;
2556
+ }
2557
+ }
2558
+ return msg;
2559
+ };
2560
+ proto.aggregator.Execution.prototype.serializeBinary = function() {
2561
+ var writer = new jspb.BinaryWriter();
2562
+ proto.aggregator.Execution.serializeBinaryToWriter(this, writer);
2563
+ return writer.getResultBuffer();
2564
+ };
2565
+ proto.aggregator.Execution.serializeBinaryToWriter = function(message, writer) {
2566
+ var f = void 0;
2567
+ f = message.getEpoch();
2568
+ if (f !== 0) {
2569
+ writer.writeInt64(
2570
+ 1,
2571
+ f
2572
+ );
2573
+ }
2574
+ f = message.getUserOpHash();
2575
+ if (f.length > 0) {
2576
+ writer.writeString(
2577
+ 2,
2578
+ f
2579
+ );
2580
+ }
2581
+ f = message.getError();
2582
+ if (f.length > 0) {
2583
+ writer.writeString(
2584
+ 3,
2585
+ f
2586
+ );
2587
+ }
2588
+ };
2589
+ proto.aggregator.Execution.prototype.getEpoch = function() {
2590
+ return (
2591
+ /** @type {number} */
2592
+ jspb.Message.getFieldWithDefault(this, 1, 0)
2593
+ );
2594
+ };
2595
+ proto.aggregator.Execution.prototype.setEpoch = function(value) {
2596
+ return jspb.Message.setProto3IntField(this, 1, value);
2597
+ };
2598
+ proto.aggregator.Execution.prototype.getUserOpHash = function() {
2599
+ return (
2600
+ /** @type {string} */
2601
+ jspb.Message.getFieldWithDefault(this, 2, "")
2602
+ );
2603
+ };
2604
+ proto.aggregator.Execution.prototype.setUserOpHash = function(value) {
2605
+ return jspb.Message.setProto3StringField(this, 2, value);
2606
+ };
2607
+ proto.aggregator.Execution.prototype.getError = function() {
2608
+ return (
2609
+ /** @type {string} */
2610
+ jspb.Message.getFieldWithDefault(this, 3, "")
2611
+ );
2612
+ };
2613
+ proto.aggregator.Execution.prototype.setError = function(value) {
2614
+ return jspb.Message.setProto3StringField(this, 3, value);
2615
+ };
2616
+ proto.aggregator.Task.repeatedFields_ = [5, 12];
2617
+ if (jspb.Message.GENERATE_TO_OBJECT) {
2618
+ proto.aggregator.Task.prototype.toObject = function(opt_includeInstance) {
2619
+ return proto.aggregator.Task.toObject(opt_includeInstance, this);
2620
+ };
2621
+ proto.aggregator.Task.toObject = function(includeInstance, msg) {
2622
+ var f, obj = {
2623
+ id: (f = msg.getId()) && proto.aggregator.UUID.toObject(includeInstance, f),
2624
+ owner: jspb.Message.getFieldWithDefault(msg, 2, ""),
2625
+ smartAccountAddress: jspb.Message.getFieldWithDefault(msg, 3, ""),
2626
+ trigger: (f = msg.getTrigger()) && proto.aggregator.TaskTrigger.toObject(includeInstance, f),
2627
+ nodesList: jspb.Message.toObjectList(
2628
+ msg.getNodesList(),
2629
+ proto.aggregator.TaskAction.toObject,
2630
+ includeInstance
2631
+ ),
2632
+ startAt: jspb.Message.getFieldWithDefault(msg, 6, 0),
2633
+ expiredAt: jspb.Message.getFieldWithDefault(msg, 7, 0),
2634
+ memo: jspb.Message.getFieldWithDefault(msg, 8, ""),
2635
+ completedAt: jspb.Message.getFieldWithDefault(msg, 9, 0),
2636
+ status: jspb.Message.getFieldWithDefault(msg, 10, 0),
2637
+ repeatable: jspb.Message.getBooleanFieldWithDefault(msg, 11, false),
2638
+ executionsList: jspb.Message.toObjectList(
2639
+ msg.getExecutionsList(),
2640
+ proto.aggregator.Execution.toObject,
2641
+ includeInstance
2642
+ )
2643
+ };
2644
+ if (includeInstance) {
2645
+ obj.$jspbMessageInstance = msg;
2646
+ }
2647
+ return obj;
2648
+ };
2649
+ }
2650
+ proto.aggregator.Task.deserializeBinary = function(bytes) {
2651
+ var reader = new jspb.BinaryReader(bytes);
2652
+ var msg = new proto.aggregator.Task();
2653
+ return proto.aggregator.Task.deserializeBinaryFromReader(msg, reader);
2654
+ };
2655
+ proto.aggregator.Task.deserializeBinaryFromReader = function(msg, reader) {
2656
+ while (reader.nextField()) {
2657
+ if (reader.isEndGroup()) {
2658
+ break;
2659
+ }
2660
+ var field = reader.getFieldNumber();
2661
+ switch (field) {
2662
+ case 1:
2663
+ var value = new proto.aggregator.UUID();
2664
+ reader.readMessage(value, proto.aggregator.UUID.deserializeBinaryFromReader);
2665
+ msg.setId(value);
2666
+ break;
2667
+ case 2:
2668
+ var value = (
2669
+ /** @type {string} */
2670
+ reader.readString()
2671
+ );
2672
+ msg.setOwner(value);
2673
+ break;
2674
+ case 3:
2675
+ var value = (
2676
+ /** @type {string} */
2677
+ reader.readString()
2678
+ );
2679
+ msg.setSmartAccountAddress(value);
2680
+ break;
2681
+ case 4:
2682
+ var value = new proto.aggregator.TaskTrigger();
2683
+ reader.readMessage(value, proto.aggregator.TaskTrigger.deserializeBinaryFromReader);
2684
+ msg.setTrigger(value);
2685
+ break;
2686
+ case 5:
2687
+ var value = new proto.aggregator.TaskAction();
2688
+ reader.readMessage(value, proto.aggregator.TaskAction.deserializeBinaryFromReader);
2689
+ msg.addNodes(value);
2690
+ break;
2691
+ case 6:
2692
+ var value = (
2693
+ /** @type {number} */
2694
+ reader.readInt64()
2695
+ );
2696
+ msg.setStartAt(value);
2697
+ break;
2698
+ case 7:
2699
+ var value = (
2700
+ /** @type {number} */
2701
+ reader.readInt64()
2702
+ );
2703
+ msg.setExpiredAt(value);
2704
+ break;
2705
+ case 8:
2706
+ var value = (
2707
+ /** @type {string} */
2708
+ reader.readString()
2709
+ );
2710
+ msg.setMemo(value);
2711
+ break;
2712
+ case 9:
2713
+ var value = (
2714
+ /** @type {number} */
2715
+ reader.readInt64()
2716
+ );
2717
+ msg.setCompletedAt(value);
2718
+ break;
2719
+ case 10:
2720
+ var value = (
2721
+ /** @type {!proto.aggregator.TaskStatus} */
2722
+ reader.readEnum()
2723
+ );
2724
+ msg.setStatus(value);
2725
+ break;
2726
+ case 11:
2727
+ var value = (
2728
+ /** @type {boolean} */
2729
+ reader.readBool()
2730
+ );
2731
+ msg.setRepeatable(value);
2732
+ break;
2733
+ case 12:
2734
+ var value = new proto.aggregator.Execution();
2735
+ reader.readMessage(value, proto.aggregator.Execution.deserializeBinaryFromReader);
2736
+ msg.addExecutions(value);
2737
+ break;
2738
+ default:
2739
+ reader.skipField();
2740
+ break;
2741
+ }
2742
+ }
2743
+ return msg;
2744
+ };
2745
+ proto.aggregator.Task.prototype.serializeBinary = function() {
2746
+ var writer = new jspb.BinaryWriter();
2747
+ proto.aggregator.Task.serializeBinaryToWriter(this, writer);
2748
+ return writer.getResultBuffer();
2749
+ };
2750
+ proto.aggregator.Task.serializeBinaryToWriter = function(message, writer) {
2751
+ var f = void 0;
2752
+ f = message.getId();
2753
+ if (f != null) {
2754
+ writer.writeMessage(
2755
+ 1,
2756
+ f,
2757
+ proto.aggregator.UUID.serializeBinaryToWriter
2758
+ );
2759
+ }
2760
+ f = message.getOwner();
2761
+ if (f.length > 0) {
2762
+ writer.writeString(
2763
+ 2,
2764
+ f
2765
+ );
2766
+ }
2767
+ f = message.getSmartAccountAddress();
2768
+ if (f.length > 0) {
2769
+ writer.writeString(
2770
+ 3,
2771
+ f
2772
+ );
2773
+ }
2774
+ f = message.getTrigger();
2775
+ if (f != null) {
2776
+ writer.writeMessage(
2777
+ 4,
2778
+ f,
2779
+ proto.aggregator.TaskTrigger.serializeBinaryToWriter
2780
+ );
2781
+ }
2782
+ f = message.getNodesList();
2783
+ if (f.length > 0) {
2784
+ writer.writeRepeatedMessage(
2785
+ 5,
2786
+ f,
2787
+ proto.aggregator.TaskAction.serializeBinaryToWriter
2788
+ );
2789
+ }
2790
+ f = message.getStartAt();
2791
+ if (f !== 0) {
2792
+ writer.writeInt64(
2793
+ 6,
2794
+ f
2795
+ );
2796
+ }
2797
+ f = message.getExpiredAt();
2798
+ if (f !== 0) {
2799
+ writer.writeInt64(
2800
+ 7,
2801
+ f
2802
+ );
2803
+ }
2804
+ f = message.getMemo();
2805
+ if (f.length > 0) {
2806
+ writer.writeString(
2807
+ 8,
2808
+ f
2809
+ );
2810
+ }
2811
+ f = message.getCompletedAt();
2812
+ if (f !== 0) {
2813
+ writer.writeInt64(
2814
+ 9,
2815
+ f
2816
+ );
2817
+ }
2818
+ f = message.getStatus();
2819
+ if (f !== 0) {
2820
+ writer.writeEnum(
2821
+ 10,
2822
+ f
2823
+ );
2824
+ }
2825
+ f = message.getRepeatable();
2826
+ if (f) {
2827
+ writer.writeBool(
2828
+ 11,
2829
+ f
2830
+ );
2831
+ }
2832
+ f = message.getExecutionsList();
2833
+ if (f.length > 0) {
2834
+ writer.writeRepeatedMessage(
2835
+ 12,
2836
+ f,
2837
+ proto.aggregator.Execution.serializeBinaryToWriter
2838
+ );
2839
+ }
2840
+ };
2841
+ proto.aggregator.Task.prototype.getId = function() {
2842
+ return (
2843
+ /** @type{?proto.aggregator.UUID} */
2844
+ jspb.Message.getWrapperField(this, proto.aggregator.UUID, 1)
2845
+ );
2846
+ };
2847
+ proto.aggregator.Task.prototype.setId = function(value) {
2848
+ return jspb.Message.setWrapperField(this, 1, value);
2849
+ };
2850
+ proto.aggregator.Task.prototype.clearId = function() {
2851
+ return this.setId(void 0);
2852
+ };
2853
+ proto.aggregator.Task.prototype.hasId = function() {
2854
+ return jspb.Message.getField(this, 1) != null;
2855
+ };
2856
+ proto.aggregator.Task.prototype.getOwner = function() {
2857
+ return (
2858
+ /** @type {string} */
2859
+ jspb.Message.getFieldWithDefault(this, 2, "")
2860
+ );
2861
+ };
2862
+ proto.aggregator.Task.prototype.setOwner = function(value) {
2863
+ return jspb.Message.setProto3StringField(this, 2, value);
2864
+ };
2865
+ proto.aggregator.Task.prototype.getSmartAccountAddress = function() {
2866
+ return (
2867
+ /** @type {string} */
2868
+ jspb.Message.getFieldWithDefault(this, 3, "")
2869
+ );
2870
+ };
2871
+ proto.aggregator.Task.prototype.setSmartAccountAddress = function(value) {
2872
+ return jspb.Message.setProto3StringField(this, 3, value);
2873
+ };
2874
+ proto.aggregator.Task.prototype.getTrigger = function() {
2875
+ return (
2876
+ /** @type{?proto.aggregator.TaskTrigger} */
2877
+ jspb.Message.getWrapperField(this, proto.aggregator.TaskTrigger, 4)
2878
+ );
2879
+ };
2880
+ proto.aggregator.Task.prototype.setTrigger = function(value) {
2881
+ return jspb.Message.setWrapperField(this, 4, value);
2882
+ };
2883
+ proto.aggregator.Task.prototype.clearTrigger = function() {
2884
+ return this.setTrigger(void 0);
2885
+ };
2886
+ proto.aggregator.Task.prototype.hasTrigger = function() {
2887
+ return jspb.Message.getField(this, 4) != null;
2888
+ };
2889
+ proto.aggregator.Task.prototype.getNodesList = function() {
2890
+ return (
2891
+ /** @type{!Array<!proto.aggregator.TaskAction>} */
2892
+ jspb.Message.getRepeatedWrapperField(this, proto.aggregator.TaskAction, 5)
2893
+ );
2894
+ };
2895
+ proto.aggregator.Task.prototype.setNodesList = function(value) {
2896
+ return jspb.Message.setRepeatedWrapperField(this, 5, value);
2897
+ };
2898
+ proto.aggregator.Task.prototype.addNodes = function(opt_value, opt_index) {
2899
+ return jspb.Message.addToRepeatedWrapperField(this, 5, opt_value, proto.aggregator.TaskAction, opt_index);
2900
+ };
2901
+ proto.aggregator.Task.prototype.clearNodesList = function() {
2902
+ return this.setNodesList([]);
2903
+ };
2904
+ proto.aggregator.Task.prototype.getStartAt = function() {
2905
+ return (
2906
+ /** @type {number} */
2907
+ jspb.Message.getFieldWithDefault(this, 6, 0)
2908
+ );
2909
+ };
2910
+ proto.aggregator.Task.prototype.setStartAt = function(value) {
2911
+ return jspb.Message.setProto3IntField(this, 6, value);
2912
+ };
2913
+ proto.aggregator.Task.prototype.getExpiredAt = function() {
2914
+ return (
2915
+ /** @type {number} */
2916
+ jspb.Message.getFieldWithDefault(this, 7, 0)
2917
+ );
2918
+ };
2919
+ proto.aggregator.Task.prototype.setExpiredAt = function(value) {
2920
+ return jspb.Message.setProto3IntField(this, 7, value);
2921
+ };
2922
+ proto.aggregator.Task.prototype.getMemo = function() {
2923
+ return (
2924
+ /** @type {string} */
2925
+ jspb.Message.getFieldWithDefault(this, 8, "")
2926
+ );
2927
+ };
2928
+ proto.aggregator.Task.prototype.setMemo = function(value) {
2929
+ return jspb.Message.setProto3StringField(this, 8, value);
2930
+ };
2931
+ proto.aggregator.Task.prototype.getCompletedAt = function() {
2932
+ return (
2933
+ /** @type {number} */
2934
+ jspb.Message.getFieldWithDefault(this, 9, 0)
2935
+ );
2936
+ };
2937
+ proto.aggregator.Task.prototype.setCompletedAt = function(value) {
2938
+ return jspb.Message.setProto3IntField(this, 9, value);
2939
+ };
2940
+ proto.aggregator.Task.prototype.getStatus = function() {
2941
+ return (
2942
+ /** @type {!proto.aggregator.TaskStatus} */
2943
+ jspb.Message.getFieldWithDefault(this, 10, 0)
2944
+ );
2945
+ };
2946
+ proto.aggregator.Task.prototype.setStatus = function(value) {
2947
+ return jspb.Message.setProto3EnumField(this, 10, value);
2948
+ };
2949
+ proto.aggregator.Task.prototype.getRepeatable = function() {
2950
+ return (
2951
+ /** @type {boolean} */
2952
+ jspb.Message.getBooleanFieldWithDefault(this, 11, false)
2953
+ );
2954
+ };
2955
+ proto.aggregator.Task.prototype.setRepeatable = function(value) {
2956
+ return jspb.Message.setProto3BooleanField(this, 11, value);
2957
+ };
2958
+ proto.aggregator.Task.prototype.getExecutionsList = function() {
2959
+ return (
2960
+ /** @type{!Array<!proto.aggregator.Execution>} */
2961
+ jspb.Message.getRepeatedWrapperField(this, proto.aggregator.Execution, 12)
2962
+ );
2963
+ };
2964
+ proto.aggregator.Task.prototype.setExecutionsList = function(value) {
2965
+ return jspb.Message.setRepeatedWrapperField(this, 12, value);
2966
+ };
2967
+ proto.aggregator.Task.prototype.addExecutions = function(opt_value, opt_index) {
2968
+ return jspb.Message.addToRepeatedWrapperField(this, 12, opt_value, proto.aggregator.Execution, opt_index);
2969
+ };
2970
+ proto.aggregator.Task.prototype.clearExecutionsList = function() {
2971
+ return this.setExecutionsList([]);
2972
+ };
2973
+ proto.aggregator.CreateTaskReq.repeatedFields_ = [2];
2974
+ if (jspb.Message.GENERATE_TO_OBJECT) {
2975
+ proto.aggregator.CreateTaskReq.prototype.toObject = function(opt_includeInstance) {
2976
+ return proto.aggregator.CreateTaskReq.toObject(opt_includeInstance, this);
2977
+ };
2978
+ proto.aggregator.CreateTaskReq.toObject = function(includeInstance, msg) {
2979
+ var f, obj = {
2980
+ trigger: (f = msg.getTrigger()) && proto.aggregator.TaskTrigger.toObject(includeInstance, f),
2981
+ actionsList: jspb.Message.toObjectList(
2982
+ msg.getActionsList(),
2983
+ proto.aggregator.TaskAction.toObject,
2984
+ includeInstance
2985
+ ),
2986
+ startAt: jspb.Message.getFieldWithDefault(msg, 3, 0),
2987
+ expiredAt: jspb.Message.getFieldWithDefault(msg, 4, 0),
2988
+ memo: jspb.Message.getFieldWithDefault(msg, 5, ""),
2989
+ repeatable: jspb.Message.getBooleanFieldWithDefault(msg, 6, false)
2990
+ };
2991
+ if (includeInstance) {
2992
+ obj.$jspbMessageInstance = msg;
2993
+ }
2994
+ return obj;
2995
+ };
2996
+ }
2997
+ proto.aggregator.CreateTaskReq.deserializeBinary = function(bytes) {
2998
+ var reader = new jspb.BinaryReader(bytes);
2999
+ var msg = new proto.aggregator.CreateTaskReq();
3000
+ return proto.aggregator.CreateTaskReq.deserializeBinaryFromReader(msg, reader);
3001
+ };
3002
+ proto.aggregator.CreateTaskReq.deserializeBinaryFromReader = function(msg, reader) {
3003
+ while (reader.nextField()) {
3004
+ if (reader.isEndGroup()) {
3005
+ break;
3006
+ }
3007
+ var field = reader.getFieldNumber();
3008
+ switch (field) {
3009
+ case 1:
3010
+ var value = new proto.aggregator.TaskTrigger();
3011
+ reader.readMessage(value, proto.aggregator.TaskTrigger.deserializeBinaryFromReader);
3012
+ msg.setTrigger(value);
3013
+ break;
3014
+ case 2:
3015
+ var value = new proto.aggregator.TaskAction();
3016
+ reader.readMessage(value, proto.aggregator.TaskAction.deserializeBinaryFromReader);
3017
+ msg.addActions(value);
3018
+ break;
3019
+ case 3:
3020
+ var value = (
3021
+ /** @type {number} */
3022
+ reader.readInt64()
3023
+ );
3024
+ msg.setStartAt(value);
3025
+ break;
3026
+ case 4:
3027
+ var value = (
3028
+ /** @type {number} */
3029
+ reader.readInt64()
3030
+ );
3031
+ msg.setExpiredAt(value);
3032
+ break;
3033
+ case 5:
3034
+ var value = (
3035
+ /** @type {string} */
3036
+ reader.readString()
3037
+ );
3038
+ msg.setMemo(value);
3039
+ break;
3040
+ case 6:
3041
+ var value = (
3042
+ /** @type {boolean} */
3043
+ reader.readBool()
3044
+ );
3045
+ msg.setRepeatable(value);
3046
+ break;
3047
+ default:
3048
+ reader.skipField();
3049
+ break;
3050
+ }
3051
+ }
3052
+ return msg;
3053
+ };
3054
+ proto.aggregator.CreateTaskReq.prototype.serializeBinary = function() {
3055
+ var writer = new jspb.BinaryWriter();
3056
+ proto.aggregator.CreateTaskReq.serializeBinaryToWriter(this, writer);
3057
+ return writer.getResultBuffer();
3058
+ };
3059
+ proto.aggregator.CreateTaskReq.serializeBinaryToWriter = function(message, writer) {
3060
+ var f = void 0;
3061
+ f = message.getTrigger();
3062
+ if (f != null) {
3063
+ writer.writeMessage(
3064
+ 1,
3065
+ f,
3066
+ proto.aggregator.TaskTrigger.serializeBinaryToWriter
3067
+ );
3068
+ }
3069
+ f = message.getActionsList();
3070
+ if (f.length > 0) {
3071
+ writer.writeRepeatedMessage(
3072
+ 2,
3073
+ f,
3074
+ proto.aggregator.TaskAction.serializeBinaryToWriter
3075
+ );
3076
+ }
3077
+ f = message.getStartAt();
3078
+ if (f !== 0) {
3079
+ writer.writeInt64(
3080
+ 3,
3081
+ f
3082
+ );
3083
+ }
3084
+ f = message.getExpiredAt();
3085
+ if (f !== 0) {
3086
+ writer.writeInt64(
3087
+ 4,
3088
+ f
3089
+ );
3090
+ }
3091
+ f = message.getMemo();
3092
+ if (f.length > 0) {
3093
+ writer.writeString(
3094
+ 5,
3095
+ f
3096
+ );
3097
+ }
3098
+ f = message.getRepeatable();
3099
+ if (f) {
3100
+ writer.writeBool(
3101
+ 6,
3102
+ f
3103
+ );
3104
+ }
3105
+ };
3106
+ proto.aggregator.CreateTaskReq.prototype.getTrigger = function() {
3107
+ return (
3108
+ /** @type{?proto.aggregator.TaskTrigger} */
3109
+ jspb.Message.getWrapperField(this, proto.aggregator.TaskTrigger, 1)
3110
+ );
3111
+ };
3112
+ proto.aggregator.CreateTaskReq.prototype.setTrigger = function(value) {
3113
+ return jspb.Message.setWrapperField(this, 1, value);
3114
+ };
3115
+ proto.aggregator.CreateTaskReq.prototype.clearTrigger = function() {
3116
+ return this.setTrigger(void 0);
3117
+ };
3118
+ proto.aggregator.CreateTaskReq.prototype.hasTrigger = function() {
3119
+ return jspb.Message.getField(this, 1) != null;
3120
+ };
3121
+ proto.aggregator.CreateTaskReq.prototype.getActionsList = function() {
3122
+ return (
3123
+ /** @type{!Array<!proto.aggregator.TaskAction>} */
3124
+ jspb.Message.getRepeatedWrapperField(this, proto.aggregator.TaskAction, 2)
3125
+ );
3126
+ };
3127
+ proto.aggregator.CreateTaskReq.prototype.setActionsList = function(value) {
3128
+ return jspb.Message.setRepeatedWrapperField(this, 2, value);
3129
+ };
3130
+ proto.aggregator.CreateTaskReq.prototype.addActions = function(opt_value, opt_index) {
3131
+ return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.aggregator.TaskAction, opt_index);
3132
+ };
3133
+ proto.aggregator.CreateTaskReq.prototype.clearActionsList = function() {
3134
+ return this.setActionsList([]);
3135
+ };
3136
+ proto.aggregator.CreateTaskReq.prototype.getStartAt = function() {
3137
+ return (
3138
+ /** @type {number} */
3139
+ jspb.Message.getFieldWithDefault(this, 3, 0)
3140
+ );
3141
+ };
3142
+ proto.aggregator.CreateTaskReq.prototype.setStartAt = function(value) {
3143
+ return jspb.Message.setProto3IntField(this, 3, value);
3144
+ };
3145
+ proto.aggregator.CreateTaskReq.prototype.getExpiredAt = function() {
3146
+ return (
3147
+ /** @type {number} */
3148
+ jspb.Message.getFieldWithDefault(this, 4, 0)
3149
+ );
3150
+ };
3151
+ proto.aggregator.CreateTaskReq.prototype.setExpiredAt = function(value) {
3152
+ return jspb.Message.setProto3IntField(this, 4, value);
3153
+ };
3154
+ proto.aggregator.CreateTaskReq.prototype.getMemo = function() {
3155
+ return (
3156
+ /** @type {string} */
3157
+ jspb.Message.getFieldWithDefault(this, 5, "")
3158
+ );
3159
+ };
3160
+ proto.aggregator.CreateTaskReq.prototype.setMemo = function(value) {
3161
+ return jspb.Message.setProto3StringField(this, 5, value);
3162
+ };
3163
+ proto.aggregator.CreateTaskReq.prototype.getRepeatable = function() {
3164
+ return (
3165
+ /** @type {boolean} */
3166
+ jspb.Message.getBooleanFieldWithDefault(this, 6, false)
3167
+ );
3168
+ };
3169
+ proto.aggregator.CreateTaskReq.prototype.setRepeatable = function(value) {
3170
+ return jspb.Message.setProto3BooleanField(this, 6, value);
3171
+ };
3172
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3173
+ proto.aggregator.CreateTaskResp.prototype.toObject = function(opt_includeInstance) {
3174
+ return proto.aggregator.CreateTaskResp.toObject(opt_includeInstance, this);
3175
+ };
3176
+ proto.aggregator.CreateTaskResp.toObject = function(includeInstance, msg) {
3177
+ var f, obj = {
3178
+ id: jspb.Message.getFieldWithDefault(msg, 1, "")
3179
+ };
3180
+ if (includeInstance) {
3181
+ obj.$jspbMessageInstance = msg;
3182
+ }
3183
+ return obj;
3184
+ };
3185
+ }
3186
+ proto.aggregator.CreateTaskResp.deserializeBinary = function(bytes) {
3187
+ var reader = new jspb.BinaryReader(bytes);
3188
+ var msg = new proto.aggregator.CreateTaskResp();
3189
+ return proto.aggregator.CreateTaskResp.deserializeBinaryFromReader(msg, reader);
3190
+ };
3191
+ proto.aggregator.CreateTaskResp.deserializeBinaryFromReader = function(msg, reader) {
3192
+ while (reader.nextField()) {
3193
+ if (reader.isEndGroup()) {
3194
+ break;
3195
+ }
3196
+ var field = reader.getFieldNumber();
3197
+ switch (field) {
3198
+ case 1:
3199
+ var value = (
3200
+ /** @type {string} */
3201
+ reader.readString()
3202
+ );
3203
+ msg.setId(value);
3204
+ break;
3205
+ default:
3206
+ reader.skipField();
3207
+ break;
3208
+ }
3209
+ }
3210
+ return msg;
3211
+ };
3212
+ proto.aggregator.CreateTaskResp.prototype.serializeBinary = function() {
3213
+ var writer = new jspb.BinaryWriter();
3214
+ proto.aggregator.CreateTaskResp.serializeBinaryToWriter(this, writer);
3215
+ return writer.getResultBuffer();
3216
+ };
3217
+ proto.aggregator.CreateTaskResp.serializeBinaryToWriter = function(message, writer) {
3218
+ var f = void 0;
3219
+ f = message.getId();
3220
+ if (f.length > 0) {
3221
+ writer.writeString(
3222
+ 1,
3223
+ f
3224
+ );
3225
+ }
3226
+ };
3227
+ proto.aggregator.CreateTaskResp.prototype.getId = function() {
3228
+ return (
3229
+ /** @type {string} */
3230
+ jspb.Message.getFieldWithDefault(this, 1, "")
3231
+ );
3232
+ };
3233
+ proto.aggregator.CreateTaskResp.prototype.setId = function(value) {
3234
+ return jspb.Message.setProto3StringField(this, 1, value);
3235
+ };
3236
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3237
+ proto.aggregator.NonceRequest.prototype.toObject = function(opt_includeInstance) {
3238
+ return proto.aggregator.NonceRequest.toObject(opt_includeInstance, this);
3239
+ };
3240
+ proto.aggregator.NonceRequest.toObject = function(includeInstance, msg) {
3241
+ var f, obj = {
3242
+ owner: jspb.Message.getFieldWithDefault(msg, 1, "")
3243
+ };
3244
+ if (includeInstance) {
3245
+ obj.$jspbMessageInstance = msg;
3246
+ }
3247
+ return obj;
3248
+ };
3249
+ }
3250
+ proto.aggregator.NonceRequest.deserializeBinary = function(bytes) {
3251
+ var reader = new jspb.BinaryReader(bytes);
3252
+ var msg = new proto.aggregator.NonceRequest();
3253
+ return proto.aggregator.NonceRequest.deserializeBinaryFromReader(msg, reader);
3254
+ };
3255
+ proto.aggregator.NonceRequest.deserializeBinaryFromReader = function(msg, reader) {
3256
+ while (reader.nextField()) {
3257
+ if (reader.isEndGroup()) {
3258
+ break;
3259
+ }
3260
+ var field = reader.getFieldNumber();
3261
+ switch (field) {
3262
+ case 1:
3263
+ var value = (
3264
+ /** @type {string} */
3265
+ reader.readString()
3266
+ );
3267
+ msg.setOwner(value);
3268
+ break;
3269
+ default:
3270
+ reader.skipField();
3271
+ break;
3272
+ }
3273
+ }
3274
+ return msg;
3275
+ };
3276
+ proto.aggregator.NonceRequest.prototype.serializeBinary = function() {
3277
+ var writer = new jspb.BinaryWriter();
3278
+ proto.aggregator.NonceRequest.serializeBinaryToWriter(this, writer);
3279
+ return writer.getResultBuffer();
3280
+ };
3281
+ proto.aggregator.NonceRequest.serializeBinaryToWriter = function(message, writer) {
3282
+ var f = void 0;
3283
+ f = message.getOwner();
3284
+ if (f.length > 0) {
3285
+ writer.writeString(
3286
+ 1,
3287
+ f
3288
+ );
3289
+ }
3290
+ };
3291
+ proto.aggregator.NonceRequest.prototype.getOwner = function() {
3292
+ return (
3293
+ /** @type {string} */
3294
+ jspb.Message.getFieldWithDefault(this, 1, "")
3295
+ );
3296
+ };
3297
+ proto.aggregator.NonceRequest.prototype.setOwner = function(value) {
3298
+ return jspb.Message.setProto3StringField(this, 1, value);
3299
+ };
3300
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3301
+ proto.aggregator.NonceResp.prototype.toObject = function(opt_includeInstance) {
3302
+ return proto.aggregator.NonceResp.toObject(opt_includeInstance, this);
3303
+ };
3304
+ proto.aggregator.NonceResp.toObject = function(includeInstance, msg) {
3305
+ var f, obj = {
3306
+ nonce: jspb.Message.getFieldWithDefault(msg, 1, "")
3307
+ };
3308
+ if (includeInstance) {
3309
+ obj.$jspbMessageInstance = msg;
3310
+ }
3311
+ return obj;
3312
+ };
3313
+ }
3314
+ proto.aggregator.NonceResp.deserializeBinary = function(bytes) {
3315
+ var reader = new jspb.BinaryReader(bytes);
3316
+ var msg = new proto.aggregator.NonceResp();
3317
+ return proto.aggregator.NonceResp.deserializeBinaryFromReader(msg, reader);
3318
+ };
3319
+ proto.aggregator.NonceResp.deserializeBinaryFromReader = function(msg, reader) {
3320
+ while (reader.nextField()) {
3321
+ if (reader.isEndGroup()) {
3322
+ break;
3323
+ }
3324
+ var field = reader.getFieldNumber();
3325
+ switch (field) {
3326
+ case 1:
3327
+ var value = (
3328
+ /** @type {string} */
3329
+ reader.readString()
3330
+ );
3331
+ msg.setNonce(value);
3332
+ break;
3333
+ default:
3334
+ reader.skipField();
3335
+ break;
3336
+ }
3337
+ }
3338
+ return msg;
3339
+ };
3340
+ proto.aggregator.NonceResp.prototype.serializeBinary = function() {
3341
+ var writer = new jspb.BinaryWriter();
3342
+ proto.aggregator.NonceResp.serializeBinaryToWriter(this, writer);
3343
+ return writer.getResultBuffer();
3344
+ };
3345
+ proto.aggregator.NonceResp.serializeBinaryToWriter = function(message, writer) {
3346
+ var f = void 0;
3347
+ f = message.getNonce();
3348
+ if (f.length > 0) {
3349
+ writer.writeString(
3350
+ 1,
3351
+ f
3352
+ );
3353
+ }
3354
+ };
3355
+ proto.aggregator.NonceResp.prototype.getNonce = function() {
3356
+ return (
3357
+ /** @type {string} */
3358
+ jspb.Message.getFieldWithDefault(this, 1, "")
3359
+ );
3360
+ };
3361
+ proto.aggregator.NonceResp.prototype.setNonce = function(value) {
3362
+ return jspb.Message.setProto3StringField(this, 1, value);
3363
+ };
3364
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3365
+ proto.aggregator.AddressRequest.prototype.toObject = function(opt_includeInstance) {
3366
+ return proto.aggregator.AddressRequest.toObject(opt_includeInstance, this);
3367
+ };
3368
+ proto.aggregator.AddressRequest.toObject = function(includeInstance, msg) {
3369
+ var f, obj = {
3370
+ owner: jspb.Message.getFieldWithDefault(msg, 1, "")
3371
+ };
3372
+ if (includeInstance) {
3373
+ obj.$jspbMessageInstance = msg;
3374
+ }
3375
+ return obj;
3376
+ };
3377
+ }
3378
+ proto.aggregator.AddressRequest.deserializeBinary = function(bytes) {
3379
+ var reader = new jspb.BinaryReader(bytes);
3380
+ var msg = new proto.aggregator.AddressRequest();
3381
+ return proto.aggregator.AddressRequest.deserializeBinaryFromReader(msg, reader);
3382
+ };
3383
+ proto.aggregator.AddressRequest.deserializeBinaryFromReader = function(msg, reader) {
3384
+ while (reader.nextField()) {
3385
+ if (reader.isEndGroup()) {
3386
+ break;
3387
+ }
3388
+ var field = reader.getFieldNumber();
3389
+ switch (field) {
3390
+ case 1:
3391
+ var value = (
3392
+ /** @type {string} */
3393
+ reader.readString()
3394
+ );
3395
+ msg.setOwner(value);
3396
+ break;
3397
+ default:
3398
+ reader.skipField();
3399
+ break;
3400
+ }
3401
+ }
3402
+ return msg;
3403
+ };
3404
+ proto.aggregator.AddressRequest.prototype.serializeBinary = function() {
3405
+ var writer = new jspb.BinaryWriter();
3406
+ proto.aggregator.AddressRequest.serializeBinaryToWriter(this, writer);
3407
+ return writer.getResultBuffer();
3408
+ };
3409
+ proto.aggregator.AddressRequest.serializeBinaryToWriter = function(message, writer) {
3410
+ var f = void 0;
3411
+ f = message.getOwner();
3412
+ if (f.length > 0) {
3413
+ writer.writeString(
3414
+ 1,
3415
+ f
3416
+ );
3417
+ }
3418
+ };
3419
+ proto.aggregator.AddressRequest.prototype.getOwner = function() {
3420
+ return (
3421
+ /** @type {string} */
3422
+ jspb.Message.getFieldWithDefault(this, 1, "")
3423
+ );
3424
+ };
3425
+ proto.aggregator.AddressRequest.prototype.setOwner = function(value) {
3426
+ return jspb.Message.setProto3StringField(this, 1, value);
3427
+ };
3428
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3429
+ proto.aggregator.AddressResp.prototype.toObject = function(opt_includeInstance) {
3430
+ return proto.aggregator.AddressResp.toObject(opt_includeInstance, this);
3431
+ };
3432
+ proto.aggregator.AddressResp.toObject = function(includeInstance, msg) {
3433
+ var f, obj = {
3434
+ smartAccountAddress: jspb.Message.getFieldWithDefault(msg, 1, ""),
3435
+ nonce: jspb.Message.getFieldWithDefault(msg, 2, "")
3436
+ };
3437
+ if (includeInstance) {
3438
+ obj.$jspbMessageInstance = msg;
3439
+ }
3440
+ return obj;
3441
+ };
3442
+ }
3443
+ proto.aggregator.AddressResp.deserializeBinary = function(bytes) {
3444
+ var reader = new jspb.BinaryReader(bytes);
3445
+ var msg = new proto.aggregator.AddressResp();
3446
+ return proto.aggregator.AddressResp.deserializeBinaryFromReader(msg, reader);
3447
+ };
3448
+ proto.aggregator.AddressResp.deserializeBinaryFromReader = function(msg, reader) {
3449
+ while (reader.nextField()) {
3450
+ if (reader.isEndGroup()) {
3451
+ break;
3452
+ }
3453
+ var field = reader.getFieldNumber();
3454
+ switch (field) {
3455
+ case 1:
3456
+ var value = (
3457
+ /** @type {string} */
3458
+ reader.readString()
3459
+ );
3460
+ msg.setSmartAccountAddress(value);
3461
+ break;
3462
+ case 2:
3463
+ var value = (
3464
+ /** @type {string} */
3465
+ reader.readString()
3466
+ );
3467
+ msg.setNonce(value);
3468
+ break;
3469
+ default:
3470
+ reader.skipField();
3471
+ break;
3472
+ }
3473
+ }
3474
+ return msg;
3475
+ };
3476
+ proto.aggregator.AddressResp.prototype.serializeBinary = function() {
3477
+ var writer = new jspb.BinaryWriter();
3478
+ proto.aggregator.AddressResp.serializeBinaryToWriter(this, writer);
3479
+ return writer.getResultBuffer();
3480
+ };
3481
+ proto.aggregator.AddressResp.serializeBinaryToWriter = function(message, writer) {
3482
+ var f = void 0;
3483
+ f = message.getSmartAccountAddress();
3484
+ if (f.length > 0) {
3485
+ writer.writeString(
3486
+ 1,
3487
+ f
3488
+ );
3489
+ }
3490
+ f = message.getNonce();
3491
+ if (f.length > 0) {
3492
+ writer.writeString(
3493
+ 2,
3494
+ f
3495
+ );
3496
+ }
3497
+ };
3498
+ proto.aggregator.AddressResp.prototype.getSmartAccountAddress = function() {
3499
+ return (
3500
+ /** @type {string} */
3501
+ jspb.Message.getFieldWithDefault(this, 1, "")
3502
+ );
3503
+ };
3504
+ proto.aggregator.AddressResp.prototype.setSmartAccountAddress = function(value) {
3505
+ return jspb.Message.setProto3StringField(this, 1, value);
3506
+ };
3507
+ proto.aggregator.AddressResp.prototype.getNonce = function() {
3508
+ return (
3509
+ /** @type {string} */
3510
+ jspb.Message.getFieldWithDefault(this, 2, "")
3511
+ );
3512
+ };
3513
+ proto.aggregator.AddressResp.prototype.setNonce = function(value) {
3514
+ return jspb.Message.setProto3StringField(this, 2, value);
3515
+ };
3516
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3517
+ proto.aggregator.ListTasksReq.prototype.toObject = function(opt_includeInstance) {
3518
+ return proto.aggregator.ListTasksReq.toObject(opt_includeInstance, this);
3519
+ };
3520
+ proto.aggregator.ListTasksReq.toObject = function(includeInstance, msg) {
3521
+ var f, obj = {};
3522
+ if (includeInstance) {
3523
+ obj.$jspbMessageInstance = msg;
3524
+ }
3525
+ return obj;
3526
+ };
3527
+ }
3528
+ proto.aggregator.ListTasksReq.deserializeBinary = function(bytes) {
3529
+ var reader = new jspb.BinaryReader(bytes);
3530
+ var msg = new proto.aggregator.ListTasksReq();
3531
+ return proto.aggregator.ListTasksReq.deserializeBinaryFromReader(msg, reader);
3532
+ };
3533
+ proto.aggregator.ListTasksReq.deserializeBinaryFromReader = function(msg, reader) {
3534
+ while (reader.nextField()) {
3535
+ if (reader.isEndGroup()) {
3536
+ break;
3537
+ }
3538
+ var field = reader.getFieldNumber();
3539
+ switch (field) {
3540
+ default:
3541
+ reader.skipField();
3542
+ break;
3543
+ }
3544
+ }
3545
+ return msg;
3546
+ };
3547
+ proto.aggregator.ListTasksReq.prototype.serializeBinary = function() {
3548
+ var writer = new jspb.BinaryWriter();
3549
+ proto.aggregator.ListTasksReq.serializeBinaryToWriter(this, writer);
3550
+ return writer.getResultBuffer();
3551
+ };
3552
+ proto.aggregator.ListTasksReq.serializeBinaryToWriter = function(message, writer) {
3553
+ var f = void 0;
3554
+ };
3555
+ proto.aggregator.ListTasksResp.repeatedFields_ = [1];
3556
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3557
+ proto.aggregator.ListTasksResp.prototype.toObject = function(opt_includeInstance) {
3558
+ return proto.aggregator.ListTasksResp.toObject(opt_includeInstance, this);
3559
+ };
3560
+ proto.aggregator.ListTasksResp.toObject = function(includeInstance, msg) {
3561
+ var f, obj = {
3562
+ tasksList: jspb.Message.toObjectList(
3563
+ msg.getTasksList(),
3564
+ proto.aggregator.ListTasksResp.TaskItemResp.toObject,
3565
+ includeInstance
3566
+ )
3567
+ };
3568
+ if (includeInstance) {
3569
+ obj.$jspbMessageInstance = msg;
3570
+ }
3571
+ return obj;
3572
+ };
3573
+ }
3574
+ proto.aggregator.ListTasksResp.deserializeBinary = function(bytes) {
3575
+ var reader = new jspb.BinaryReader(bytes);
3576
+ var msg = new proto.aggregator.ListTasksResp();
3577
+ return proto.aggregator.ListTasksResp.deserializeBinaryFromReader(msg, reader);
3578
+ };
3579
+ proto.aggregator.ListTasksResp.deserializeBinaryFromReader = function(msg, reader) {
3580
+ while (reader.nextField()) {
3581
+ if (reader.isEndGroup()) {
3582
+ break;
3583
+ }
3584
+ var field = reader.getFieldNumber();
3585
+ switch (field) {
3586
+ case 1:
3587
+ var value = new proto.aggregator.ListTasksResp.TaskItemResp();
3588
+ reader.readMessage(value, proto.aggregator.ListTasksResp.TaskItemResp.deserializeBinaryFromReader);
3589
+ msg.addTasks(value);
3590
+ break;
3591
+ default:
3592
+ reader.skipField();
3593
+ break;
3594
+ }
3595
+ }
3596
+ return msg;
3597
+ };
3598
+ proto.aggregator.ListTasksResp.prototype.serializeBinary = function() {
3599
+ var writer = new jspb.BinaryWriter();
3600
+ proto.aggregator.ListTasksResp.serializeBinaryToWriter(this, writer);
3601
+ return writer.getResultBuffer();
3602
+ };
3603
+ proto.aggregator.ListTasksResp.serializeBinaryToWriter = function(message, writer) {
3604
+ var f = void 0;
3605
+ f = message.getTasksList();
3606
+ if (f.length > 0) {
3607
+ writer.writeRepeatedMessage(
3608
+ 1,
3609
+ f,
3610
+ proto.aggregator.ListTasksResp.TaskItemResp.serializeBinaryToWriter
3611
+ );
3612
+ }
3613
+ };
3614
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3615
+ proto.aggregator.ListTasksResp.TaskItemResp.prototype.toObject = function(opt_includeInstance) {
3616
+ return proto.aggregator.ListTasksResp.TaskItemResp.toObject(opt_includeInstance, this);
3617
+ };
3618
+ proto.aggregator.ListTasksResp.TaskItemResp.toObject = function(includeInstance, msg) {
3619
+ var f, obj = {
3620
+ id: jspb.Message.getFieldWithDefault(msg, 1, ""),
3621
+ status: jspb.Message.getFieldWithDefault(msg, 2, 0)
3622
+ };
3623
+ if (includeInstance) {
3624
+ obj.$jspbMessageInstance = msg;
3625
+ }
3626
+ return obj;
3627
+ };
3628
+ }
3629
+ proto.aggregator.ListTasksResp.TaskItemResp.deserializeBinary = function(bytes) {
3630
+ var reader = new jspb.BinaryReader(bytes);
3631
+ var msg = new proto.aggregator.ListTasksResp.TaskItemResp();
3632
+ return proto.aggregator.ListTasksResp.TaskItemResp.deserializeBinaryFromReader(msg, reader);
3633
+ };
3634
+ proto.aggregator.ListTasksResp.TaskItemResp.deserializeBinaryFromReader = function(msg, reader) {
3635
+ while (reader.nextField()) {
3636
+ if (reader.isEndGroup()) {
3637
+ break;
3638
+ }
3639
+ var field = reader.getFieldNumber();
3640
+ switch (field) {
3641
+ case 1:
3642
+ var value = (
3643
+ /** @type {string} */
3644
+ reader.readString()
3645
+ );
3646
+ msg.setId(value);
3647
+ break;
3648
+ case 2:
3649
+ var value = (
3650
+ /** @type {!proto.aggregator.TaskStatus} */
3651
+ reader.readEnum()
3652
+ );
3653
+ msg.setStatus(value);
3654
+ break;
3655
+ default:
3656
+ reader.skipField();
3657
+ break;
3658
+ }
3659
+ }
3660
+ return msg;
3661
+ };
3662
+ proto.aggregator.ListTasksResp.TaskItemResp.prototype.serializeBinary = function() {
3663
+ var writer = new jspb.BinaryWriter();
3664
+ proto.aggregator.ListTasksResp.TaskItemResp.serializeBinaryToWriter(this, writer);
3665
+ return writer.getResultBuffer();
3666
+ };
3667
+ proto.aggregator.ListTasksResp.TaskItemResp.serializeBinaryToWriter = function(message, writer) {
3668
+ var f = void 0;
3669
+ f = message.getId();
3670
+ if (f.length > 0) {
3671
+ writer.writeString(
3672
+ 1,
3673
+ f
3674
+ );
3675
+ }
3676
+ f = message.getStatus();
3677
+ if (f !== 0) {
3678
+ writer.writeEnum(
3679
+ 2,
3680
+ f
3681
+ );
3682
+ }
3683
+ };
3684
+ proto.aggregator.ListTasksResp.TaskItemResp.prototype.getId = function() {
3685
+ return (
3686
+ /** @type {string} */
3687
+ jspb.Message.getFieldWithDefault(this, 1, "")
3688
+ );
3689
+ };
3690
+ proto.aggregator.ListTasksResp.TaskItemResp.prototype.setId = function(value) {
3691
+ return jspb.Message.setProto3StringField(this, 1, value);
3692
+ };
3693
+ proto.aggregator.ListTasksResp.TaskItemResp.prototype.getStatus = function() {
3694
+ return (
3695
+ /** @type {!proto.aggregator.TaskStatus} */
3696
+ jspb.Message.getFieldWithDefault(this, 2, 0)
3697
+ );
3698
+ };
3699
+ proto.aggregator.ListTasksResp.TaskItemResp.prototype.setStatus = function(value) {
3700
+ return jspb.Message.setProto3EnumField(this, 2, value);
3701
+ };
3702
+ proto.aggregator.ListTasksResp.prototype.getTasksList = function() {
3703
+ return (
3704
+ /** @type{!Array<!proto.aggregator.ListTasksResp.TaskItemResp>} */
3705
+ jspb.Message.getRepeatedWrapperField(this, proto.aggregator.ListTasksResp.TaskItemResp, 1)
3706
+ );
3707
+ };
3708
+ proto.aggregator.ListTasksResp.prototype.setTasksList = function(value) {
3709
+ return jspb.Message.setRepeatedWrapperField(this, 1, value);
3710
+ };
3711
+ proto.aggregator.ListTasksResp.prototype.addTasks = function(opt_value, opt_index) {
3712
+ return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.aggregator.ListTasksResp.TaskItemResp, opt_index);
3713
+ };
3714
+ proto.aggregator.ListTasksResp.prototype.clearTasksList = function() {
3715
+ return this.setTasksList([]);
3716
+ };
3717
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3718
+ proto.aggregator.GetKeyReq.prototype.toObject = function(opt_includeInstance) {
3719
+ return proto.aggregator.GetKeyReq.toObject(opt_includeInstance, this);
3720
+ };
3721
+ proto.aggregator.GetKeyReq.toObject = function(includeInstance, msg) {
3722
+ var f, obj = {
3723
+ owner: jspb.Message.getFieldWithDefault(msg, 1, ""),
3724
+ expiredAt: jspb.Message.getFieldWithDefault(msg, 2, 0),
3725
+ signature: jspb.Message.getFieldWithDefault(msg, 3, "")
3726
+ };
3727
+ if (includeInstance) {
3728
+ obj.$jspbMessageInstance = msg;
3729
+ }
3730
+ return obj;
3731
+ };
3732
+ }
3733
+ proto.aggregator.GetKeyReq.deserializeBinary = function(bytes) {
3734
+ var reader = new jspb.BinaryReader(bytes);
3735
+ var msg = new proto.aggregator.GetKeyReq();
3736
+ return proto.aggregator.GetKeyReq.deserializeBinaryFromReader(msg, reader);
3737
+ };
3738
+ proto.aggregator.GetKeyReq.deserializeBinaryFromReader = function(msg, reader) {
3739
+ while (reader.nextField()) {
3740
+ if (reader.isEndGroup()) {
3741
+ break;
3742
+ }
3743
+ var field = reader.getFieldNumber();
3744
+ switch (field) {
3745
+ case 1:
3746
+ var value = (
3747
+ /** @type {string} */
3748
+ reader.readString()
3749
+ );
3750
+ msg.setOwner(value);
3751
+ break;
3752
+ case 2:
3753
+ var value = (
3754
+ /** @type {number} */
3755
+ reader.readInt64()
3756
+ );
3757
+ msg.setExpiredAt(value);
3758
+ break;
3759
+ case 3:
3760
+ var value = (
3761
+ /** @type {string} */
3762
+ reader.readString()
3763
+ );
3764
+ msg.setSignature(value);
3765
+ break;
3766
+ default:
3767
+ reader.skipField();
3768
+ break;
3769
+ }
3770
+ }
3771
+ return msg;
3772
+ };
3773
+ proto.aggregator.GetKeyReq.prototype.serializeBinary = function() {
3774
+ var writer = new jspb.BinaryWriter();
3775
+ proto.aggregator.GetKeyReq.serializeBinaryToWriter(this, writer);
3776
+ return writer.getResultBuffer();
3777
+ };
3778
+ proto.aggregator.GetKeyReq.serializeBinaryToWriter = function(message, writer) {
3779
+ var f = void 0;
3780
+ f = message.getOwner();
3781
+ if (f.length > 0) {
3782
+ writer.writeString(
3783
+ 1,
3784
+ f
3785
+ );
3786
+ }
3787
+ f = message.getExpiredAt();
3788
+ if (f !== 0) {
3789
+ writer.writeInt64(
3790
+ 2,
3791
+ f
3792
+ );
3793
+ }
3794
+ f = message.getSignature();
3795
+ if (f.length > 0) {
3796
+ writer.writeString(
3797
+ 3,
3798
+ f
3799
+ );
3800
+ }
3801
+ };
3802
+ proto.aggregator.GetKeyReq.prototype.getOwner = function() {
3803
+ return (
3804
+ /** @type {string} */
3805
+ jspb.Message.getFieldWithDefault(this, 1, "")
3806
+ );
3807
+ };
3808
+ proto.aggregator.GetKeyReq.prototype.setOwner = function(value) {
3809
+ return jspb.Message.setProto3StringField(this, 1, value);
3810
+ };
3811
+ proto.aggregator.GetKeyReq.prototype.getExpiredAt = function() {
3812
+ return (
3813
+ /** @type {number} */
3814
+ jspb.Message.getFieldWithDefault(this, 2, 0)
3815
+ );
3816
+ };
3817
+ proto.aggregator.GetKeyReq.prototype.setExpiredAt = function(value) {
3818
+ return jspb.Message.setProto3IntField(this, 2, value);
3819
+ };
3820
+ proto.aggregator.GetKeyReq.prototype.getSignature = function() {
3821
+ return (
3822
+ /** @type {string} */
3823
+ jspb.Message.getFieldWithDefault(this, 3, "")
3824
+ );
3825
+ };
3826
+ proto.aggregator.GetKeyReq.prototype.setSignature = function(value) {
3827
+ return jspb.Message.setProto3StringField(this, 3, value);
3828
+ };
3829
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3830
+ proto.aggregator.KeyResp.prototype.toObject = function(opt_includeInstance) {
3831
+ return proto.aggregator.KeyResp.toObject(opt_includeInstance, this);
3832
+ };
3833
+ proto.aggregator.KeyResp.toObject = function(includeInstance, msg) {
3834
+ var f, obj = {
3835
+ key: jspb.Message.getFieldWithDefault(msg, 1, "")
3836
+ };
3837
+ if (includeInstance) {
3838
+ obj.$jspbMessageInstance = msg;
3839
+ }
3840
+ return obj;
3841
+ };
3842
+ }
3843
+ proto.aggregator.KeyResp.deserializeBinary = function(bytes) {
3844
+ var reader = new jspb.BinaryReader(bytes);
3845
+ var msg = new proto.aggregator.KeyResp();
3846
+ return proto.aggregator.KeyResp.deserializeBinaryFromReader(msg, reader);
3847
+ };
3848
+ proto.aggregator.KeyResp.deserializeBinaryFromReader = function(msg, reader) {
3849
+ while (reader.nextField()) {
3850
+ if (reader.isEndGroup()) {
3851
+ break;
3852
+ }
3853
+ var field = reader.getFieldNumber();
3854
+ switch (field) {
3855
+ case 1:
3856
+ var value = (
3857
+ /** @type {string} */
3858
+ reader.readString()
3859
+ );
3860
+ msg.setKey(value);
3861
+ break;
3862
+ default:
3863
+ reader.skipField();
3864
+ break;
3865
+ }
3866
+ }
3867
+ return msg;
3868
+ };
3869
+ proto.aggregator.KeyResp.prototype.serializeBinary = function() {
3870
+ var writer = new jspb.BinaryWriter();
3871
+ proto.aggregator.KeyResp.serializeBinaryToWriter(this, writer);
3872
+ return writer.getResultBuffer();
3873
+ };
3874
+ proto.aggregator.KeyResp.serializeBinaryToWriter = function(message, writer) {
3875
+ var f = void 0;
3876
+ f = message.getKey();
3877
+ if (f.length > 0) {
3878
+ writer.writeString(
3879
+ 1,
3880
+ f
3881
+ );
3882
+ }
3883
+ };
3884
+ proto.aggregator.KeyResp.prototype.getKey = function() {
3885
+ return (
3886
+ /** @type {string} */
3887
+ jspb.Message.getFieldWithDefault(this, 1, "")
3888
+ );
3889
+ };
3890
+ proto.aggregator.KeyResp.prototype.setKey = function(value) {
3891
+ return jspb.Message.setProto3StringField(this, 1, value);
3892
+ };
3893
+ proto.aggregator.UpdateChecksReq.repeatedFields_ = [3];
3894
+ if (jspb.Message.GENERATE_TO_OBJECT) {
3895
+ proto.aggregator.UpdateChecksReq.prototype.toObject = function(opt_includeInstance) {
3896
+ return proto.aggregator.UpdateChecksReq.toObject(opt_includeInstance, this);
3897
+ };
3898
+ proto.aggregator.UpdateChecksReq.toObject = function(includeInstance, msg) {
3899
+ var f, obj = {
3900
+ address: jspb.Message.getFieldWithDefault(msg, 1, ""),
3901
+ signature: jspb.Message.getFieldWithDefault(msg, 2, ""),
3902
+ idList: (f = jspb.Message.getRepeatedField(msg, 3)) == null ? void 0 : f
3903
+ };
3904
+ if (includeInstance) {
3905
+ obj.$jspbMessageInstance = msg;
3906
+ }
3907
+ return obj;
3908
+ };
3909
+ }
3910
+ proto.aggregator.UpdateChecksReq.deserializeBinary = function(bytes) {
3911
+ var reader = new jspb.BinaryReader(bytes);
3912
+ var msg = new proto.aggregator.UpdateChecksReq();
3913
+ return proto.aggregator.UpdateChecksReq.deserializeBinaryFromReader(msg, reader);
3914
+ };
3915
+ proto.aggregator.UpdateChecksReq.deserializeBinaryFromReader = function(msg, reader) {
3916
+ while (reader.nextField()) {
3917
+ if (reader.isEndGroup()) {
3918
+ break;
3919
+ }
3920
+ var field = reader.getFieldNumber();
3921
+ switch (field) {
3922
+ case 1:
3923
+ var value = (
3924
+ /** @type {string} */
3925
+ reader.readString()
3926
+ );
3927
+ msg.setAddress(value);
3928
+ break;
3929
+ case 2:
3930
+ var value = (
3931
+ /** @type {string} */
3932
+ reader.readString()
3933
+ );
3934
+ msg.setSignature(value);
3935
+ break;
3936
+ case 3:
3937
+ var value = (
3938
+ /** @type {string} */
3939
+ reader.readString()
3940
+ );
3941
+ msg.addId(value);
3942
+ break;
3943
+ default:
3944
+ reader.skipField();
3945
+ break;
3946
+ }
3947
+ }
3948
+ return msg;
3949
+ };
3950
+ proto.aggregator.UpdateChecksReq.prototype.serializeBinary = function() {
3951
+ var writer = new jspb.BinaryWriter();
3952
+ proto.aggregator.UpdateChecksReq.serializeBinaryToWriter(this, writer);
3953
+ return writer.getResultBuffer();
3954
+ };
3955
+ proto.aggregator.UpdateChecksReq.serializeBinaryToWriter = function(message, writer) {
3956
+ var f = void 0;
3957
+ f = message.getAddress();
3958
+ if (f.length > 0) {
3959
+ writer.writeString(
3960
+ 1,
3961
+ f
3962
+ );
3963
+ }
3964
+ f = message.getSignature();
3965
+ if (f.length > 0) {
3966
+ writer.writeString(
3967
+ 2,
3968
+ f
3969
+ );
3970
+ }
3971
+ f = message.getIdList();
3972
+ if (f.length > 0) {
3973
+ writer.writeRepeatedString(
3974
+ 3,
3975
+ f
3976
+ );
3977
+ }
3978
+ };
3979
+ proto.aggregator.UpdateChecksReq.prototype.getAddress = function() {
3980
+ return (
3981
+ /** @type {string} */
3982
+ jspb.Message.getFieldWithDefault(this, 1, "")
3983
+ );
3984
+ };
3985
+ proto.aggregator.UpdateChecksReq.prototype.setAddress = function(value) {
3986
+ return jspb.Message.setProto3StringField(this, 1, value);
3987
+ };
3988
+ proto.aggregator.UpdateChecksReq.prototype.getSignature = function() {
3989
+ return (
3990
+ /** @type {string} */
3991
+ jspb.Message.getFieldWithDefault(this, 2, "")
3992
+ );
3993
+ };
3994
+ proto.aggregator.UpdateChecksReq.prototype.setSignature = function(value) {
3995
+ return jspb.Message.setProto3StringField(this, 2, value);
3996
+ };
3997
+ proto.aggregator.UpdateChecksReq.prototype.getIdList = function() {
3998
+ return (
3999
+ /** @type {!Array<string>} */
4000
+ jspb.Message.getRepeatedField(this, 3)
4001
+ );
4002
+ };
4003
+ proto.aggregator.UpdateChecksReq.prototype.setIdList = function(value) {
4004
+ return jspb.Message.setField(this, 3, value || []);
4005
+ };
4006
+ proto.aggregator.UpdateChecksReq.prototype.addId = function(value, opt_index) {
4007
+ return jspb.Message.addToRepeatedField(this, 3, value, opt_index);
4008
+ };
4009
+ proto.aggregator.UpdateChecksReq.prototype.clearIdList = function() {
4010
+ return this.setIdList([]);
4011
+ };
4012
+ if (jspb.Message.GENERATE_TO_OBJECT) {
4013
+ proto.aggregator.UpdateChecksResp.prototype.toObject = function(opt_includeInstance) {
4014
+ return proto.aggregator.UpdateChecksResp.toObject(opt_includeInstance, this);
4015
+ };
4016
+ proto.aggregator.UpdateChecksResp.toObject = function(includeInstance, msg) {
4017
+ var f, obj = {
4018
+ updatedAt: (f = msg.getUpdatedAt()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f)
4019
+ };
4020
+ if (includeInstance) {
4021
+ obj.$jspbMessageInstance = msg;
4022
+ }
4023
+ return obj;
4024
+ };
4025
+ }
4026
+ proto.aggregator.UpdateChecksResp.deserializeBinary = function(bytes) {
4027
+ var reader = new jspb.BinaryReader(bytes);
4028
+ var msg = new proto.aggregator.UpdateChecksResp();
4029
+ return proto.aggregator.UpdateChecksResp.deserializeBinaryFromReader(msg, reader);
4030
+ };
4031
+ proto.aggregator.UpdateChecksResp.deserializeBinaryFromReader = function(msg, reader) {
4032
+ while (reader.nextField()) {
4033
+ if (reader.isEndGroup()) {
4034
+ break;
4035
+ }
4036
+ var field = reader.getFieldNumber();
4037
+ switch (field) {
4038
+ case 1:
4039
+ var value = new google_protobuf_timestamp_pb.Timestamp();
4040
+ reader.readMessage(value, google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader);
4041
+ msg.setUpdatedAt(value);
4042
+ break;
4043
+ default:
4044
+ reader.skipField();
4045
+ break;
4046
+ }
4047
+ }
4048
+ return msg;
4049
+ };
4050
+ proto.aggregator.UpdateChecksResp.prototype.serializeBinary = function() {
4051
+ var writer = new jspb.BinaryWriter();
4052
+ proto.aggregator.UpdateChecksResp.serializeBinaryToWriter(this, writer);
4053
+ return writer.getResultBuffer();
4054
+ };
4055
+ proto.aggregator.UpdateChecksResp.serializeBinaryToWriter = function(message, writer) {
4056
+ var f = void 0;
4057
+ f = message.getUpdatedAt();
4058
+ if (f != null) {
4059
+ writer.writeMessage(
4060
+ 1,
4061
+ f,
4062
+ google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter
4063
+ );
4064
+ }
4065
+ };
4066
+ proto.aggregator.UpdateChecksResp.prototype.getUpdatedAt = function() {
4067
+ return (
4068
+ /** @type{?proto.google.protobuf.Timestamp} */
4069
+ jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 1)
4070
+ );
4071
+ };
4072
+ proto.aggregator.UpdateChecksResp.prototype.setUpdatedAt = function(value) {
4073
+ return jspb.Message.setWrapperField(this, 1, value);
4074
+ };
4075
+ proto.aggregator.UpdateChecksResp.prototype.clearUpdatedAt = function() {
4076
+ return this.setUpdatedAt(void 0);
4077
+ };
4078
+ proto.aggregator.UpdateChecksResp.prototype.hasUpdatedAt = function() {
4079
+ return jspb.Message.getField(this, 1) != null;
4080
+ };
4081
+ proto.aggregator.TriggerType = {
4082
+ TIMETRIGGER: 0,
4083
+ CONTRACTQUERYTRIGGER: 1,
4084
+ EXPRESSIONTRIGGER: 2
4085
+ };
4086
+ proto.aggregator.TaskType = {
4087
+ ETHTRANSFERTASK: 0,
4088
+ CONTRACTEXECUTIONTASK: 1,
4089
+ GRAPHQLDATAQUERYTASK: 2,
4090
+ HTTPAPICALLTASK: 3,
4091
+ CUSTOMCODETASK: 4,
4092
+ BRANCHACTIONTASK: 5
4093
+ };
4094
+ proto.aggregator.TaskStatus = {
4095
+ ACTIVE: 0,
4096
+ COMPLETED: 1,
4097
+ FAILED: 2,
4098
+ CANCELED: 3,
4099
+ EXECUTING: 4
4100
+ };
4101
+ proto.aggregator.CustomCodeType = {
4102
+ JAVASCRIPT: 0
4103
+ };
4104
+ goog.object.extend(exports, proto.aggregator);
4105
+ ({ Task, CreateTaskReq, CreateTaskResp, GetKeyReq, KeyResp, UpdateChecksReq, UpdateChecksResp } = proto.aggregator);
4106
+ }
4107
+ });
4108
+
4109
+ // src/index.ts
4110
+ var src_exports = {};
4111
+ __export(src_exports, {
4112
+ default: () => Client,
4113
+ getKeyRequestMessage: () => getKeyRequestMessage
4114
+ });
4115
+ module.exports = __toCommonJS(src_exports);
4116
+ var grpc2 = __toESM(require("@grpc/grpc-js"), 1);
4117
+
4118
+ // src/config.ts
4119
+ var DEFAULT_JWT_EXPIRATION = 24 * 60 * 60;
4120
+ var configs = {
4121
+ development: {
4122
+ AVS_RPC_URL: process.env.AVS_RPC_URL || "localhost:2206"
4123
+ },
4124
+ staging: {
4125
+ AVS_RPC_URL: "aggregator-holesky.avaprotocol.org:2206"
4126
+ },
4127
+ production: {
4128
+ AVS_RPC_URL: "aggregator.avaprotocol.org:2206"
4129
+ }
4130
+ };
4131
+ function getRpcEndpoint(env) {
4132
+ return configs[env].AVS_RPC_URL;
4133
+ }
4134
+
4135
+ // src/auth.ts
4136
+ var getKeyRequestMessage = (address, expiredAt) => {
4137
+ return `key request for ${address} expired at ${expiredAt}`;
4138
+ };
4139
+
4140
+ // grpc_codegen/avs_grpc_pb.js
4141
+ var grpc = require("@grpc/grpc-js");
4142
+ var avs_pb = (init_avs_pb(), __toCommonJS(avs_pb_exports));
4143
+ var google_protobuf_timestamp_pb2 = require("google-protobuf/google/protobuf/timestamp_pb.js");
4144
+ var google_protobuf_wrappers_pb2 = require("google-protobuf/google/protobuf/wrappers_pb.js");
4145
+ function serialize_aggregator_AddressRequest(arg) {
4146
+ if (!(arg instanceof avs_pb.AddressRequest)) {
4147
+ throw new Error("Expected argument of type aggregator.AddressRequest");
4148
+ }
4149
+ return Buffer.from(arg.serializeBinary());
4150
+ }
4151
+ function deserialize_aggregator_AddressRequest(buffer_arg) {
4152
+ return avs_pb.AddressRequest.deserializeBinary(new Uint8Array(buffer_arg));
4153
+ }
4154
+ function serialize_aggregator_AddressResp(arg) {
4155
+ if (!(arg instanceof avs_pb.AddressResp)) {
4156
+ throw new Error("Expected argument of type aggregator.AddressResp");
4157
+ }
4158
+ return Buffer.from(arg.serializeBinary());
4159
+ }
4160
+ function deserialize_aggregator_AddressResp(buffer_arg) {
4161
+ return avs_pb.AddressResp.deserializeBinary(new Uint8Array(buffer_arg));
4162
+ }
4163
+ function serialize_aggregator_Checkin(arg) {
4164
+ if (!(arg instanceof avs_pb.Checkin)) {
4165
+ throw new Error("Expected argument of type aggregator.Checkin");
4166
+ }
4167
+ return Buffer.from(arg.serializeBinary());
4168
+ }
4169
+ function deserialize_aggregator_Checkin(buffer_arg) {
4170
+ return avs_pb.Checkin.deserializeBinary(new Uint8Array(buffer_arg));
4171
+ }
4172
+ function serialize_aggregator_CheckinResp(arg) {
4173
+ if (!(arg instanceof avs_pb.CheckinResp)) {
4174
+ throw new Error("Expected argument of type aggregator.CheckinResp");
4175
+ }
4176
+ return Buffer.from(arg.serializeBinary());
4177
+ }
4178
+ function deserialize_aggregator_CheckinResp(buffer_arg) {
4179
+ return avs_pb.CheckinResp.deserializeBinary(new Uint8Array(buffer_arg));
4180
+ }
4181
+ function serialize_aggregator_CreateTaskReq(arg) {
4182
+ if (!(arg instanceof avs_pb.CreateTaskReq)) {
4183
+ throw new Error("Expected argument of type aggregator.CreateTaskReq");
4184
+ }
4185
+ return Buffer.from(arg.serializeBinary());
4186
+ }
4187
+ function deserialize_aggregator_CreateTaskReq(buffer_arg) {
4188
+ return avs_pb.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
4189
+ }
4190
+ function serialize_aggregator_CreateTaskResp(arg) {
4191
+ if (!(arg instanceof avs_pb.CreateTaskResp)) {
4192
+ throw new Error("Expected argument of type aggregator.CreateTaskResp");
4193
+ }
4194
+ return Buffer.from(arg.serializeBinary());
4195
+ }
4196
+ function deserialize_aggregator_CreateTaskResp(buffer_arg) {
4197
+ return avs_pb.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
4198
+ }
4199
+ function serialize_aggregator_GetKeyReq(arg) {
4200
+ if (!(arg instanceof avs_pb.GetKeyReq)) {
4201
+ throw new Error("Expected argument of type aggregator.GetKeyReq");
4202
+ }
4203
+ return Buffer.from(arg.serializeBinary());
4204
+ }
4205
+ function deserialize_aggregator_GetKeyReq(buffer_arg) {
4206
+ return avs_pb.GetKeyReq.deserializeBinary(new Uint8Array(buffer_arg));
4207
+ }
4208
+ function serialize_aggregator_KeyResp(arg) {
4209
+ if (!(arg instanceof avs_pb.KeyResp)) {
4210
+ throw new Error("Expected argument of type aggregator.KeyResp");
4211
+ }
4212
+ return Buffer.from(arg.serializeBinary());
4213
+ }
4214
+ function deserialize_aggregator_KeyResp(buffer_arg) {
4215
+ return avs_pb.KeyResp.deserializeBinary(new Uint8Array(buffer_arg));
4216
+ }
4217
+ function serialize_aggregator_ListTasksReq(arg) {
4218
+ if (!(arg instanceof avs_pb.ListTasksReq)) {
4219
+ throw new Error("Expected argument of type aggregator.ListTasksReq");
4220
+ }
4221
+ return Buffer.from(arg.serializeBinary());
4222
+ }
4223
+ function deserialize_aggregator_ListTasksReq(buffer_arg) {
4224
+ return avs_pb.ListTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
4225
+ }
4226
+ function serialize_aggregator_ListTasksResp(arg) {
4227
+ if (!(arg instanceof avs_pb.ListTasksResp)) {
4228
+ throw new Error("Expected argument of type aggregator.ListTasksResp");
4229
+ }
4230
+ return Buffer.from(arg.serializeBinary());
4231
+ }
4232
+ function deserialize_aggregator_ListTasksResp(buffer_arg) {
4233
+ return avs_pb.ListTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
4234
+ }
4235
+ function serialize_aggregator_NonceRequest(arg) {
4236
+ if (!(arg instanceof avs_pb.NonceRequest)) {
4237
+ throw new Error("Expected argument of type aggregator.NonceRequest");
4238
+ }
4239
+ return Buffer.from(arg.serializeBinary());
4240
+ }
4241
+ function deserialize_aggregator_NonceRequest(buffer_arg) {
4242
+ return avs_pb.NonceRequest.deserializeBinary(new Uint8Array(buffer_arg));
4243
+ }
4244
+ function serialize_aggregator_NonceResp(arg) {
4245
+ if (!(arg instanceof avs_pb.NonceResp)) {
4246
+ throw new Error("Expected argument of type aggregator.NonceResp");
4247
+ }
4248
+ return Buffer.from(arg.serializeBinary());
4249
+ }
4250
+ function deserialize_aggregator_NonceResp(buffer_arg) {
4251
+ return avs_pb.NonceResp.deserializeBinary(new Uint8Array(buffer_arg));
4252
+ }
4253
+ function serialize_aggregator_SyncTasksReq(arg) {
4254
+ if (!(arg instanceof avs_pb.SyncTasksReq)) {
4255
+ throw new Error("Expected argument of type aggregator.SyncTasksReq");
4256
+ }
4257
+ return Buffer.from(arg.serializeBinary());
4258
+ }
4259
+ function deserialize_aggregator_SyncTasksReq(buffer_arg) {
4260
+ return avs_pb.SyncTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
4261
+ }
4262
+ function serialize_aggregator_SyncTasksResp(arg) {
4263
+ if (!(arg instanceof avs_pb.SyncTasksResp)) {
4264
+ throw new Error("Expected argument of type aggregator.SyncTasksResp");
4265
+ }
4266
+ return Buffer.from(arg.serializeBinary());
4267
+ }
4268
+ function deserialize_aggregator_SyncTasksResp(buffer_arg) {
4269
+ return avs_pb.SyncTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
4270
+ }
4271
+ function serialize_aggregator_Task(arg) {
4272
+ if (!(arg instanceof avs_pb.Task)) {
4273
+ throw new Error("Expected argument of type aggregator.Task");
4274
+ }
4275
+ return Buffer.from(arg.serializeBinary());
4276
+ }
4277
+ function deserialize_aggregator_Task(buffer_arg) {
4278
+ return avs_pb.Task.deserializeBinary(new Uint8Array(buffer_arg));
4279
+ }
4280
+ function serialize_aggregator_UUID(arg) {
4281
+ if (!(arg instanceof avs_pb.UUID)) {
4282
+ throw new Error("Expected argument of type aggregator.UUID");
4283
+ }
4284
+ return Buffer.from(arg.serializeBinary());
4285
+ }
4286
+ function deserialize_aggregator_UUID(buffer_arg) {
4287
+ return avs_pb.UUID.deserializeBinary(new Uint8Array(buffer_arg));
4288
+ }
4289
+ function serialize_aggregator_UpdateChecksReq(arg) {
4290
+ if (!(arg instanceof avs_pb.UpdateChecksReq)) {
4291
+ throw new Error("Expected argument of type aggregator.UpdateChecksReq");
4292
+ }
4293
+ return Buffer.from(arg.serializeBinary());
4294
+ }
4295
+ function deserialize_aggregator_UpdateChecksReq(buffer_arg) {
4296
+ return avs_pb.UpdateChecksReq.deserializeBinary(new Uint8Array(buffer_arg));
4297
+ }
4298
+ function serialize_aggregator_UpdateChecksResp(arg) {
4299
+ if (!(arg instanceof avs_pb.UpdateChecksResp)) {
4300
+ throw new Error("Expected argument of type aggregator.UpdateChecksResp");
4301
+ }
4302
+ return Buffer.from(arg.serializeBinary());
4303
+ }
4304
+ function deserialize_aggregator_UpdateChecksResp(buffer_arg) {
4305
+ return avs_pb.UpdateChecksResp.deserializeBinary(new Uint8Array(buffer_arg));
4306
+ }
4307
+ function serialize_google_protobuf_BoolValue(arg) {
4308
+ if (!(arg instanceof google_protobuf_wrappers_pb2.BoolValue)) {
4309
+ throw new Error("Expected argument of type google.protobuf.BoolValue");
4310
+ }
4311
+ return Buffer.from(arg.serializeBinary());
4312
+ }
4313
+ function deserialize_google_protobuf_BoolValue(buffer_arg) {
4314
+ return google_protobuf_wrappers_pb2.BoolValue.deserializeBinary(new Uint8Array(buffer_arg));
4315
+ }
4316
+ var AggregatorService = {
4317
+ // Auth
4318
+ getKey: {
4319
+ path: "/aggregator.Aggregator/GetKey",
4320
+ requestStream: false,
4321
+ responseStream: false,
4322
+ requestType: avs_pb.GetKeyReq,
4323
+ responseType: avs_pb.KeyResp,
4324
+ requestSerialize: serialize_aggregator_GetKeyReq,
4325
+ requestDeserialize: deserialize_aggregator_GetKeyReq,
4326
+ responseSerialize: serialize_aggregator_KeyResp,
4327
+ responseDeserialize: deserialize_aggregator_KeyResp
4328
+ },
4329
+ // Smart Acccount
4330
+ getNonce: {
4331
+ path: "/aggregator.Aggregator/GetNonce",
4332
+ requestStream: false,
4333
+ responseStream: false,
4334
+ requestType: avs_pb.NonceRequest,
4335
+ responseType: avs_pb.NonceResp,
4336
+ requestSerialize: serialize_aggregator_NonceRequest,
4337
+ requestDeserialize: deserialize_aggregator_NonceRequest,
4338
+ responseSerialize: serialize_aggregator_NonceResp,
4339
+ responseDeserialize: deserialize_aggregator_NonceResp
4340
+ },
4341
+ getSmartAccountAddress: {
4342
+ path: "/aggregator.Aggregator/GetSmartAccountAddress",
4343
+ requestStream: false,
4344
+ responseStream: false,
4345
+ requestType: avs_pb.AddressRequest,
4346
+ responseType: avs_pb.AddressResp,
4347
+ requestSerialize: serialize_aggregator_AddressRequest,
4348
+ requestDeserialize: deserialize_aggregator_AddressRequest,
4349
+ responseSerialize: serialize_aggregator_AddressResp,
4350
+ responseDeserialize: deserialize_aggregator_AddressResp
4351
+ },
4352
+ // Task Management
4353
+ createTask: {
4354
+ path: "/aggregator.Aggregator/CreateTask",
4355
+ requestStream: false,
4356
+ responseStream: false,
4357
+ requestType: avs_pb.CreateTaskReq,
4358
+ responseType: avs_pb.CreateTaskResp,
4359
+ requestSerialize: serialize_aggregator_CreateTaskReq,
4360
+ requestDeserialize: deserialize_aggregator_CreateTaskReq,
4361
+ responseSerialize: serialize_aggregator_CreateTaskResp,
4362
+ responseDeserialize: deserialize_aggregator_CreateTaskResp
4363
+ },
4364
+ listTasks: {
4365
+ path: "/aggregator.Aggregator/ListTasks",
4366
+ requestStream: false,
4367
+ responseStream: false,
4368
+ requestType: avs_pb.ListTasksReq,
4369
+ responseType: avs_pb.ListTasksResp,
4370
+ requestSerialize: serialize_aggregator_ListTasksReq,
4371
+ requestDeserialize: deserialize_aggregator_ListTasksReq,
4372
+ responseSerialize: serialize_aggregator_ListTasksResp,
4373
+ responseDeserialize: deserialize_aggregator_ListTasksResp
4374
+ },
4375
+ getTask: {
4376
+ path: "/aggregator.Aggregator/GetTask",
4377
+ requestStream: false,
4378
+ responseStream: false,
4379
+ requestType: avs_pb.UUID,
4380
+ responseType: avs_pb.Task,
4381
+ requestSerialize: serialize_aggregator_UUID,
4382
+ requestDeserialize: deserialize_aggregator_UUID,
4383
+ responseSerialize: serialize_aggregator_Task,
4384
+ responseDeserialize: deserialize_aggregator_Task
4385
+ },
4386
+ cancelTask: {
4387
+ path: "/aggregator.Aggregator/CancelTask",
4388
+ requestStream: false,
4389
+ responseStream: false,
4390
+ requestType: avs_pb.UUID,
4391
+ responseType: google_protobuf_wrappers_pb2.BoolValue,
4392
+ requestSerialize: serialize_aggregator_UUID,
4393
+ requestDeserialize: deserialize_aggregator_UUID,
4394
+ responseSerialize: serialize_google_protobuf_BoolValue,
4395
+ responseDeserialize: deserialize_google_protobuf_BoolValue
4396
+ },
4397
+ deleteTask: {
4398
+ path: "/aggregator.Aggregator/DeleteTask",
4399
+ requestStream: false,
4400
+ responseStream: false,
4401
+ requestType: avs_pb.UUID,
4402
+ responseType: google_protobuf_wrappers_pb2.BoolValue,
4403
+ requestSerialize: serialize_aggregator_UUID,
4404
+ requestDeserialize: deserialize_aggregator_UUID,
4405
+ responseSerialize: serialize_google_protobuf_BoolValue,
4406
+ responseDeserialize: deserialize_google_protobuf_BoolValue
4407
+ },
4408
+ // Operator endpoint
4409
+ ping: {
4410
+ path: "/aggregator.Aggregator/Ping",
4411
+ requestStream: false,
4412
+ responseStream: false,
4413
+ requestType: avs_pb.Checkin,
4414
+ responseType: avs_pb.CheckinResp,
4415
+ requestSerialize: serialize_aggregator_Checkin,
4416
+ requestDeserialize: deserialize_aggregator_Checkin,
4417
+ responseSerialize: serialize_aggregator_CheckinResp,
4418
+ responseDeserialize: deserialize_aggregator_CheckinResp
4419
+ },
4420
+ syncTasks: {
4421
+ path: "/aggregator.Aggregator/SyncTasks",
4422
+ requestStream: false,
4423
+ responseStream: true,
4424
+ requestType: avs_pb.SyncTasksReq,
4425
+ responseType: avs_pb.SyncTasksResp,
4426
+ requestSerialize: serialize_aggregator_SyncTasksReq,
4427
+ requestDeserialize: deserialize_aggregator_SyncTasksReq,
4428
+ responseSerialize: serialize_aggregator_SyncTasksResp,
4429
+ responseDeserialize: deserialize_aggregator_SyncTasksResp
4430
+ },
4431
+ updateChecks: {
4432
+ path: "/aggregator.Aggregator/UpdateChecks",
4433
+ requestStream: false,
4434
+ responseStream: false,
4435
+ requestType: avs_pb.UpdateChecksReq,
4436
+ responseType: avs_pb.UpdateChecksResp,
4437
+ requestSerialize: serialize_aggregator_UpdateChecksReq,
4438
+ requestDeserialize: deserialize_aggregator_UpdateChecksReq,
4439
+ responseSerialize: serialize_aggregator_UpdateChecksResp,
4440
+ responseDeserialize: deserialize_aggregator_UpdateChecksResp
4441
+ }
4442
+ };
4443
+ var AggregatorClient = grpc.makeGenericClientConstructor(AggregatorService);
4444
+
4445
+ // src/index.ts
4446
+ init_avs_pb();
4447
+ var metadata = new grpc2.Metadata();
4448
+ var BaseClient = class {
4449
+ constructor(opts) {
4450
+ this.env = opts.env || "production";
4451
+ this.rpcClient = new AggregatorClient(
4452
+ getRpcEndpoint(this.env),
4453
+ // TODO: switch to the TLS after we're able to update all the operator
4454
+ grpc2.credentials.createInsecure()
4455
+ );
4456
+ console.log("this.rpcClient:", this.rpcClient);
4457
+ }
4458
+ // async authWithJwtToken(
4459
+ // address: string,
4460
+ // jwtToken: string,
4461
+ // expiredAt?: number
4462
+ // ): Promise<KeyExchangeResp> {
4463
+ // console.log("Authenticating with JWT token: ", jwtToken);
4464
+ // // Use the provided expiredAt or set it to 24 hours from now if not provided
4465
+ // const expirationTime =
4466
+ // expiredAt || Math.floor(Date.now() / 1000) + DEFAULT_JWT_EXPIRATION;
4467
+ // const result: avsPb.KeyResp = await this._callRPC<
4468
+ // avsPb.KeyResp,
4469
+ // avsPb.GetKeyReq
4470
+ // >("getKey", {
4471
+ // owner: address,
4472
+ // expired_at: expirationTime,
4473
+ // signature: jwtToken,
4474
+ // });
4475
+ // this.authkey = result.getKey();
4476
+ // return { key: result.getKey() };
4477
+ // }
4478
+ // This flow can be used where the signature is generate from outside, such as in front-end and pass in
4479
+ async authWithSignature(address, signature, expiredAtEpoch) {
4480
+ console.log(
4481
+ "Authenticating with signature:",
4482
+ signature,
4483
+ "Expired at epoch:",
4484
+ expiredAtEpoch
4485
+ );
4486
+ const request = new GetKeyReq();
4487
+ request.setOwner(address);
4488
+ request.setExpiredAt(expiredAtEpoch);
4489
+ request.setSignature(signature);
4490
+ let result = await this._callRPC(
4491
+ "getKey",
4492
+ request
4493
+ );
4494
+ console.log("result:", result);
4495
+ this.authkey = result.getKey();
4496
+ return { key: result.getKey() };
4497
+ }
4498
+ isAuthenticated() {
4499
+ return !!this.authkey;
4500
+ }
4501
+ _callRPC(method, request) {
4502
+ return new Promise((resolve, reject) => {
4503
+ this.rpcClient[method].bind(this.rpcClient)(
4504
+ request,
4505
+ metadata,
4506
+ (error, response) => {
4507
+ if (error) reject(error);
4508
+ else resolve(response);
4509
+ }
4510
+ );
4511
+ });
4512
+ }
4513
+ };
4514
+ var Client = class extends BaseClient {
4515
+ constructor(config) {
4516
+ super(config);
4517
+ }
4518
+ };
4519
+ // Annotate the CommonJS export names for ESM import in node:
4520
+ 0 && (module.exports = {
4521
+ getKeyRequestMessage
4522
+ });