@avaprotocol/sdk-js 0.6.0

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