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