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