@avaprotocol/sdk-js 1.3.4-dev.2 → 1.3.4

package/dist/index.mjs

@@ -60,11 +60,13 @@ var require_avs_pb = __commonJS({
     goog.exportSymbol("proto.aggregator.Condition", null, global);
     goog.exportSymbol("proto.aggregator.ContractReadNode", null, global);
     goog.exportSymbol("proto.aggregator.ContractWriteNode", null, global);
+    goog.exportSymbol("proto.aggregator.CreateOrUpdateSecretReq", null, global);
     goog.exportSymbol("proto.aggregator.CreateTaskReq", null, global);
     goog.exportSymbol("proto.aggregator.CreateTaskResp", null, global);
     goog.exportSymbol("proto.aggregator.CronCondition", null, global);
     goog.exportSymbol("proto.aggregator.CustomCodeLang", null, global);
     goog.exportSymbol("proto.aggregator.CustomCodeNode", null, global);
+    goog.exportSymbol("proto.aggregator.DeleteSecretReq", null, global);
     goog.exportSymbol("proto.aggregator.ETHTransferNode", null, global);
     goog.exportSymbol("proto.aggregator.Error", null, global);
     goog.exportSymbol("proto.aggregator.EventCondition", null, global);
@@ -84,6 +86,9 @@ var require_avs_pb = __commonJS({
     goog.exportSymbol("proto.aggregator.KeyResp", null, global);
     goog.exportSymbol("proto.aggregator.ListExecutionsReq", null, global);
     goog.exportSymbol("proto.aggregator.ListExecutionsResp", null, global);
+    goog.exportSymbol("proto.aggregator.ListSecretsReq", null, global);
+    goog.exportSymbol("proto.aggregator.ListSecretsResp", null, global);
+    goog.exportSymbol("proto.aggregator.ListSecretsResp.ResponseSecret", null, global);
     goog.exportSymbol("proto.aggregator.ListTasksReq", null, global);
     goog.exportSymbol("proto.aggregator.ListTasksResp", null, global);
     goog.exportSymbol("proto.aggregator.ListTasksResp.Item", null, global);
@@ -135,7 +140,7 @@ var require_avs_pb = __commonJS({
       proto.aggregator.BlockCondition.displayName = "proto.aggregator.BlockCondition";
     }
     proto.aggregator.EventCondition = function(opt_data) {
-      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+      jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.EventCondition.repeatedFields_, null);
     };
     goog.inherits(proto.aggregator.EventCondition, jspb.Message);
     if (goog.DEBUG && !COMPILED) {
@@ -407,6 +412,41 @@ var require_avs_pb = __commonJS({
     if (goog.DEBUG && !COMPILED) {
       proto.aggregator.UserTriggerTaskResp.displayName = "proto.aggregator.UserTriggerTaskResp";
     }
+    proto.aggregator.CreateOrUpdateSecretReq = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.CreateOrUpdateSecretReq, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.CreateOrUpdateSecretReq.displayName = "proto.aggregator.CreateOrUpdateSecretReq";
+    }
+    proto.aggregator.ListSecretsReq = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.ListSecretsReq, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.ListSecretsReq.displayName = "proto.aggregator.ListSecretsReq";
+    }
+    proto.aggregator.ListSecretsResp = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.ListSecretsResp.repeatedFields_, null);
+    };
+    goog.inherits(proto.aggregator.ListSecretsResp, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.ListSecretsResp.displayName = "proto.aggregator.ListSecretsResp";
+    }
+    proto.aggregator.ListSecretsResp.ResponseSecret = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.ListSecretsResp.ResponseSecret, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.ListSecretsResp.ResponseSecret.displayName = "proto.aggregator.ListSecretsResp.ResponseSecret";
+    }
+    proto.aggregator.DeleteSecretReq = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.DeleteSecretReq, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.DeleteSecretReq.displayName = "proto.aggregator.DeleteSecretReq";
+    }
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.IdReq.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.IdReq.toObject(opt_includeInstance, this);
@@ -679,13 +719,19 @@ var require_avs_pb = __commonJS({
     proto.aggregator.BlockCondition.prototype.setInterval = function(value) {
       return jspb.Message.setProto3IntField(this, 1, value);
     };
+    proto.aggregator.EventCondition.repeatedFields_ = [1];
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.EventCondition.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.EventCondition.toObject(opt_includeInstance, this);
       };
       proto.aggregator.EventCondition.toObject = function(includeInstance, msg) {
         var f, obj = {
-          expression: jspb.Message.getFieldWithDefault(msg, 1, "")
+          matcherList: jspb.Message.toObjectList(
+            msg.getMatcherList(),
+            proto.aggregator.EventCondition.Matcher.toObject,
+            includeInstance
+          ),
+          expression: jspb.Message.getFieldWithDefault(msg, 2, "")
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -706,6 +752,11 @@ var require_avs_pb = __commonJS({
         var field = reader.getFieldNumber();
         switch (field) {
           case 1:
+            var value = new proto.aggregator.EventCondition.Matcher();
+            reader.readMessage(value, proto.aggregator.EventCondition.Matcher.deserializeBinaryFromReader);
+            msg.addMatcher(value);
+            break;
+          case 2:
             var value = (
               /** @type {string} */
               reader.readString()
@@ -726,10 +777,18 @@ var require_avs_pb = __commonJS({
     };
     proto.aggregator.EventCondition.serializeBinaryToWriter = function(message, writer) {
       var f = void 0;
+      f = message.getMatcherList();
+      if (f.length > 0) {
+        writer.writeRepeatedMessage(
+          1,
+          f,
+          proto.aggregator.EventCondition.Matcher.serializeBinaryToWriter
+        );
+      }
       f = message.getExpression();
       if (f.length > 0) {
         writer.writeString(
-          1,
+          2,
           f
         );
       }
@@ -829,14 +888,29 @@ var require_avs_pb = __commonJS({
     proto.aggregator.EventCondition.Matcher.prototype.clearValueList = function() {
       return this.setValueList([]);
     };
+    proto.aggregator.EventCondition.prototype.getMatcherList = function() {
+      return (
+        /** @type{!Array<!proto.aggregator.EventCondition.Matcher>} */
+        jspb.Message.getRepeatedWrapperField(this, proto.aggregator.EventCondition.Matcher, 1)
+      );
+    };
+    proto.aggregator.EventCondition.prototype.setMatcherList = function(value) {
+      return jspb.Message.setRepeatedWrapperField(this, 1, value);
+    };
+    proto.aggregator.EventCondition.prototype.addMatcher = function(opt_value, opt_index) {
+      return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.aggregator.EventCondition.Matcher, opt_index);
+    };
+    proto.aggregator.EventCondition.prototype.clearMatcherList = function() {
+      return this.setMatcherList([]);
+    };
     proto.aggregator.EventCondition.prototype.getExpression = function() {
       return (
         /** @type {string} */
-        jspb.Message.getFieldWithDefault(this, 1, "")
+        jspb.Message.getFieldWithDefault(this, 2, "")
       );
     };
     proto.aggregator.EventCondition.prototype.setExpression = function(value) {
-      return jspb.Message.setProto3StringField(this, 1, value);
+      return jspb.Message.setProto3StringField(this, 2, value);
     };
     proto.aggregator.TaskTrigger.oneofGroups_ = [[2, 3, 4, 5, 6]];
     proto.aggregator.TaskTrigger.TriggerTypeCase = {
@@ -1296,8 +1370,7 @@ var require_avs_pb = __commonJS({
         var f, obj = {
           contractAddress: jspb.Message.getFieldWithDefault(msg, 1, ""),
           callData: jspb.Message.getFieldWithDefault(msg, 2, ""),
-          contractAbi: jspb.Message.getFieldWithDefault(msg, 3, ""),
-          method: jspb.Message.getFieldWithDefault(msg, 4, "")
+          contractAbi: jspb.Message.getFieldWithDefault(msg, 3, "")
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -1338,13 +1411,6 @@ var require_avs_pb = __commonJS({
             );
             msg.setContractAbi(value);
             break;
-          case 4:
-            var value = (
-              /** @type {string} */
-              reader.readString()
-            );
-            msg.setMethod(value);
-            break;
           default:
             reader.skipField();
             break;
@@ -1380,13 +1446,6 @@ var require_avs_pb = __commonJS({
           f
         );
       }
-      f = message.getMethod();
-      if (f.length > 0) {
-        writer.writeString(
-          4,
-          f
-        );
-      }
     };
     proto.aggregator.ContractReadNode.prototype.getContractAddress = function() {
       return (
@@ -1415,15 +1474,6 @@ var require_avs_pb = __commonJS({
     proto.aggregator.ContractReadNode.prototype.setContractAbi = function(value) {
       return jspb.Message.setProto3StringField(this, 3, value);
     };
-    proto.aggregator.ContractReadNode.prototype.getMethod = function() {
-      return (
-        /** @type {string} */
-        jspb.Message.getFieldWithDefault(this, 4, "")
-      );
-    };
-    proto.aggregator.ContractReadNode.prototype.setMethod = function(value) {
-      return jspb.Message.setProto3StringField(this, 4, value);
-    };
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.GraphQLQueryNode.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.GraphQLQueryNode.toObject(opt_includeInstance, this);
@@ -5862,7 +5912,12 @@ var require_avs_pb = __commonJS({
         var f, obj = {
           address: jspb.Message.getFieldWithDefault(msg, 1, ""),
           salt: jspb.Message.getFieldWithDefault(msg, 2, ""),
-          factoryAddress: jspb.Message.getFieldWithDefault(msg, 3, "")
+          factoryAddress: jspb.Message.getFieldWithDefault(msg, 3, ""),
+          totalTaskCount: jspb.Message.getFieldWithDefault(msg, 4, 0),
+          activeTaskCount: jspb.Message.getFieldWithDefault(msg, 5, 0),
+          completedTaskCount: jspb.Message.getFieldWithDefault(msg, 6, 0),
+          failedTaskCount: jspb.Message.getFieldWithDefault(msg, 7, 0),
+          canceledTaskCount: jspb.Message.getFieldWithDefault(msg, 8, 0)
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -5903,6 +5958,41 @@ var require_avs_pb = __commonJS({
             );
             msg.setFactoryAddress(value);
             break;
+          case 4:
+            var value = (
+              /** @type {number} */
+              reader.readUint64()
+            );
+            msg.setTotalTaskCount(value);
+            break;
+          case 5:
+            var value = (
+              /** @type {number} */
+              reader.readUint64()
+            );
+            msg.setActiveTaskCount(value);
+            break;
+          case 6:
+            var value = (
+              /** @type {number} */
+              reader.readUint64()
+            );
+            msg.setCompletedTaskCount(value);
+            break;
+          case 7:
+            var value = (
+              /** @type {number} */
+              reader.readUint64()
+            );
+            msg.setFailedTaskCount(value);
+            break;
+          case 8:
+            var value = (
+              /** @type {number} */
+              reader.readUint64()
+            );
+            msg.setCanceledTaskCount(value);
+            break;
           default:
             reader.skipField();
             break;
@@ -5938,6 +6028,41 @@ var require_avs_pb = __commonJS({
           f
         );
       }
+      f = message.getTotalTaskCount();
+      if (f !== 0) {
+        writer.writeUint64(
+          4,
+          f
+        );
+      }
+      f = message.getActiveTaskCount();
+      if (f !== 0) {
+        writer.writeUint64(
+          5,
+          f
+        );
+      }
+      f = message.getCompletedTaskCount();
+      if (f !== 0) {
+        writer.writeUint64(
+          6,
+          f
+        );
+      }
+      f = message.getFailedTaskCount();
+      if (f !== 0) {
+        writer.writeUint64(
+          7,
+          f
+        );
+      }
+      f = message.getCanceledTaskCount();
+      if (f !== 0) {
+        writer.writeUint64(
+          8,
+          f
+        );
+      }
     };
     proto.aggregator.GetWalletResp.prototype.getAddress = function() {
       return (
@@ -5966,6 +6091,51 @@ var require_avs_pb = __commonJS({
     proto.aggregator.GetWalletResp.prototype.setFactoryAddress = function(value) {
       return jspb.Message.setProto3StringField(this, 3, value);
     };
+    proto.aggregator.GetWalletResp.prototype.getTotalTaskCount = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 4, 0)
+      );
+    };
+    proto.aggregator.GetWalletResp.prototype.setTotalTaskCount = function(value) {
+      return jspb.Message.setProto3IntField(this, 4, value);
+    };
+    proto.aggregator.GetWalletResp.prototype.getActiveTaskCount = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 5, 0)
+      );
+    };
+    proto.aggregator.GetWalletResp.prototype.setActiveTaskCount = function(value) {
+      return jspb.Message.setProto3IntField(this, 5, value);
+    };
+    proto.aggregator.GetWalletResp.prototype.getCompletedTaskCount = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 6, 0)
+      );
+    };
+    proto.aggregator.GetWalletResp.prototype.setCompletedTaskCount = function(value) {
+      return jspb.Message.setProto3IntField(this, 6, value);
+    };
+    proto.aggregator.GetWalletResp.prototype.getFailedTaskCount = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 7, 0)
+      );
+    };
+    proto.aggregator.GetWalletResp.prototype.setFailedTaskCount = function(value) {
+      return jspb.Message.setProto3IntField(this, 7, value);
+    };
+    proto.aggregator.GetWalletResp.prototype.getCanceledTaskCount = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 8, 0)
+      );
+    };
+    proto.aggregator.GetWalletResp.prototype.setCanceledTaskCount = function(value) {
+      return jspb.Message.setProto3IntField(this, 8, value);
+    };
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.UserTriggerTaskReq.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.UserTriggerTaskReq.toObject(opt_includeInstance, this);
@@ -6171,231 +6341,789 @@ var require_avs_pb = __commonJS({
     proto.aggregator.UserTriggerTaskResp.prototype.setStatus = function(value) {
       return jspb.Message.setProto3EnumField(this, 2, value);
     };
-    proto.aggregator.Error = {
-      UNKNOWERROR: 0,
-      RPCNODEERROR: 1e3,
-      STORAGEUNAVAILABLE: 2e3,
-      STORAGEWRITEERROR: 2001,
-      SMARTWALLETRPCERROR: 6e3,
-      SMARTWALLETNOTFOUNDERROR: 6001,
-      TASKDATACORRUPTED: 7e3,
-      TASKDATAMISSINGERROR: 7001,
-      TASKTRIGGERERROR: 7003
-    };
-    proto.aggregator.TaskStatus = {
-      ACTIVE: 0,
-      COMPLETED: 1,
-      FAILED: 2,
-      CANCELED: 3,
-      EXECUTING: 4
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.CreateOrUpdateSecretReq.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.CreateOrUpdateSecretReq.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.CreateOrUpdateSecretReq.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          name: jspb.Message.getFieldWithDefault(msg, 1, ""),
+          secret: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          workflowId: jspb.Message.getFieldWithDefault(msg, 3, ""),
+          orgId: jspb.Message.getFieldWithDefault(msg, 4, "")
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.CreateOrUpdateSecretReq.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.CreateOrUpdateSecretReq();
+      return proto.aggregator.CreateOrUpdateSecretReq.deserializeBinaryFromReader(msg, reader);
     };
-    proto.aggregator.ExecutionStatus = {
-      QUEUED: 0,
-      FINISHED: 2
+    proto.aggregator.CreateOrUpdateSecretReq.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setName(value);
+            break;
+          case 2:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setSecret(value);
+            break;
+          case 3:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setWorkflowId(value);
+            break;
+          case 4:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setOrgId(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
     };
-    proto.aggregator.CustomCodeLang = {
-      JAVASCRIPT: 0
+    proto.aggregator.CreateOrUpdateSecretReq.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.CreateOrUpdateSecretReq.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
     };
-    goog.object.extend(exports, proto.aggregator);
-  }
-});
-
-// ../../grpc_codegen/avs_grpc_pb.js
-var require_avs_grpc_pb = __commonJS({
-  "../../grpc_codegen/avs_grpc_pb.js"(exports) {
-    "use strict";
-    var grpc = __require("@grpc/grpc-js");
-    var avs_pb20 = require_avs_pb();
-    var google_protobuf_wrappers_pb = __require("google-protobuf/google/protobuf/wrappers_pb.js");
-    var google_protobuf_timestamp_pb = __require("google-protobuf/google/protobuf/timestamp_pb.js");
-    function serialize_aggregator_CreateTaskReq(arg) {
-      if (!(arg instanceof avs_pb20.CreateTaskReq)) {
-        throw new Error("Expected argument of type aggregator.CreateTaskReq");
+    proto.aggregator.CreateOrUpdateSecretReq.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getName();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
       }
-      return Buffer.from(arg.serializeBinary());
-    }
+      f = message.getSecret();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
+      }
+      f = message.getWorkflowId();
+      if (f.length > 0) {
+        writer.writeString(
+          3,
+          f
+        );
+      }
+      f = message.getOrgId();
+      if (f.length > 0) {
+        writer.writeString(
+          4,
+          f
+        );
+      }
+    };
+    proto.aggregator.CreateOrUpdateSecretReq.prototype.getName = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.CreateOrUpdateSecretReq.prototype.setName = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    proto.aggregator.CreateOrUpdateSecretReq.prototype.getSecret = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
+      );
+    };
+    proto.aggregator.CreateOrUpdateSecretReq.prototype.setSecret = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
+    };
+    proto.aggregator.CreateOrUpdateSecretReq.prototype.getWorkflowId = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 3, "")
+      );
+    };
+    proto.aggregator.CreateOrUpdateSecretReq.prototype.setWorkflowId = function(value) {
+      return jspb.Message.setProto3StringField(this, 3, value);
+    };
+    proto.aggregator.CreateOrUpdateSecretReq.prototype.getOrgId = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 4, "")
+      );
+    };
+    proto.aggregator.CreateOrUpdateSecretReq.prototype.setOrgId = function(value) {
+      return jspb.Message.setProto3StringField(this, 4, value);
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.ListSecretsReq.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.ListSecretsReq.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.ListSecretsReq.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          workflowId: jspb.Message.getFieldWithDefault(msg, 1, "")
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.ListSecretsReq.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.ListSecretsReq();
+      return proto.aggregator.ListSecretsReq.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.ListSecretsReq.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setWorkflowId(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.ListSecretsReq.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.ListSecretsReq.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.ListSecretsReq.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getWorkflowId();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
+      }
+    };
+    proto.aggregator.ListSecretsReq.prototype.getWorkflowId = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.ListSecretsReq.prototype.setWorkflowId = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    proto.aggregator.ListSecretsResp.repeatedFields_ = [1];
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.ListSecretsResp.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.ListSecretsResp.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.ListSecretsResp.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          itemsList: jspb.Message.toObjectList(
+            msg.getItemsList(),
+            proto.aggregator.ListSecretsResp.ResponseSecret.toObject,
+            includeInstance
+          )
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.ListSecretsResp.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.ListSecretsResp();
+      return proto.aggregator.ListSecretsResp.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.ListSecretsResp.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = new proto.aggregator.ListSecretsResp.ResponseSecret();
+            reader.readMessage(value, proto.aggregator.ListSecretsResp.ResponseSecret.deserializeBinaryFromReader);
+            msg.addItems(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.ListSecretsResp.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.ListSecretsResp.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.ListSecretsResp.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getItemsList();
+      if (f.length > 0) {
+        writer.writeRepeatedMessage(
+          1,
+          f,
+          proto.aggregator.ListSecretsResp.ResponseSecret.serializeBinaryToWriter
+        );
+      }
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.ListSecretsResp.ResponseSecret.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.ListSecretsResp.ResponseSecret.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.ListSecretsResp.ResponseSecret.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          name: jspb.Message.getFieldWithDefault(msg, 1, ""),
+          scope: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          workflowId: jspb.Message.getFieldWithDefault(msg, 4, ""),
+          orgId: jspb.Message.getFieldWithDefault(msg, 5, "")
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.ListSecretsResp.ResponseSecret.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.ListSecretsResp.ResponseSecret();
+      return proto.aggregator.ListSecretsResp.ResponseSecret.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setName(value);
+            break;
+          case 2:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setScope(value);
+            break;
+          case 4:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setWorkflowId(value);
+            break;
+          case 5:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setOrgId(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.ListSecretsResp.ResponseSecret.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getName();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
+      }
+      f = message.getScope();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
+      }
+      f = message.getWorkflowId();
+      if (f.length > 0) {
+        writer.writeString(
+          4,
+          f
+        );
+      }
+      f = message.getOrgId();
+      if (f.length > 0) {
+        writer.writeString(
+          5,
+          f
+        );
+      }
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.prototype.getName = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.prototype.setName = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.prototype.getScope = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
+      );
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.prototype.setScope = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.prototype.getWorkflowId = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 4, "")
+      );
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.prototype.setWorkflowId = function(value) {
+      return jspb.Message.setProto3StringField(this, 4, value);
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.prototype.getOrgId = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 5, "")
+      );
+    };
+    proto.aggregator.ListSecretsResp.ResponseSecret.prototype.setOrgId = function(value) {
+      return jspb.Message.setProto3StringField(this, 5, value);
+    };
+    proto.aggregator.ListSecretsResp.prototype.getItemsList = function() {
+      return (
+        /** @type{!Array<!proto.aggregator.ListSecretsResp.ResponseSecret>} */
+        jspb.Message.getRepeatedWrapperField(this, proto.aggregator.ListSecretsResp.ResponseSecret, 1)
+      );
+    };
+    proto.aggregator.ListSecretsResp.prototype.setItemsList = function(value) {
+      return jspb.Message.setRepeatedWrapperField(this, 1, value);
+    };
+    proto.aggregator.ListSecretsResp.prototype.addItems = function(opt_value, opt_index) {
+      return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.aggregator.ListSecretsResp.ResponseSecret, opt_index);
+    };
+    proto.aggregator.ListSecretsResp.prototype.clearItemsList = function() {
+      return this.setItemsList([]);
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.DeleteSecretReq.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.DeleteSecretReq.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.DeleteSecretReq.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          name: jspb.Message.getFieldWithDefault(msg, 1, ""),
+          workflowId: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          orgId: jspb.Message.getFieldWithDefault(msg, 3, "")
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.DeleteSecretReq.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.DeleteSecretReq();
+      return proto.aggregator.DeleteSecretReq.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.DeleteSecretReq.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setName(value);
+            break;
+          case 2:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setWorkflowId(value);
+            break;
+          case 3:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setOrgId(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.DeleteSecretReq.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.DeleteSecretReq.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.DeleteSecretReq.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getName();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
+      }
+      f = message.getWorkflowId();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
+      }
+      f = message.getOrgId();
+      if (f.length > 0) {
+        writer.writeString(
+          3,
+          f
+        );
+      }
+    };
+    proto.aggregator.DeleteSecretReq.prototype.getName = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.DeleteSecretReq.prototype.setName = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    proto.aggregator.DeleteSecretReq.prototype.getWorkflowId = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
+      );
+    };
+    proto.aggregator.DeleteSecretReq.prototype.setWorkflowId = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
+    };
+    proto.aggregator.DeleteSecretReq.prototype.getOrgId = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 3, "")
+      );
+    };
+    proto.aggregator.DeleteSecretReq.prototype.setOrgId = function(value) {
+      return jspb.Message.setProto3StringField(this, 3, value);
+    };
+    proto.aggregator.Error = {
+      UNKNOWERROR: 0,
+      RPCNODEERROR: 1e3,
+      STORAGEUNAVAILABLE: 2e3,
+      STORAGEWRITEERROR: 2001,
+      SMARTWALLETRPCERROR: 6e3,
+      SMARTWALLETNOTFOUNDERROR: 6001,
+      TASKDATACORRUPTED: 7e3,
+      TASKDATAMISSINGERROR: 7001,
+      TASKTRIGGERERROR: 7003
+    };
+    proto.aggregator.TaskStatus = {
+      ACTIVE: 0,
+      COMPLETED: 1,
+      FAILED: 2,
+      CANCELED: 3,
+      EXECUTING: 4
+    };
+    proto.aggregator.ExecutionStatus = {
+      QUEUED: 0,
+      FINISHED: 2
+    };
+    proto.aggregator.CustomCodeLang = {
+      JAVASCRIPT: 0
+    };
+    goog.object.extend(exports, proto.aggregator);
+  }
+});
+
+// ../../grpc_codegen/avs_grpc_pb.js
+var require_avs_grpc_pb = __commonJS({
+  "../../grpc_codegen/avs_grpc_pb.js"(exports) {
+    "use strict";
+    var grpc = __require("@grpc/grpc-js");
+    var avs_pb22 = require_avs_pb();
+    var google_protobuf_wrappers_pb = __require("google-protobuf/google/protobuf/wrappers_pb.js");
+    var google_protobuf_timestamp_pb = __require("google-protobuf/google/protobuf/timestamp_pb.js");
+    function serialize_aggregator_CreateOrUpdateSecretReq(arg) {
+      if (!(arg instanceof avs_pb22.CreateOrUpdateSecretReq)) {
+        throw new Error("Expected argument of type aggregator.CreateOrUpdateSecretReq");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
+    function deserialize_aggregator_CreateOrUpdateSecretReq(buffer_arg) {
+      return avs_pb22.CreateOrUpdateSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
+    }
+    function serialize_aggregator_CreateTaskReq(arg) {
+      if (!(arg instanceof avs_pb22.CreateTaskReq)) {
+        throw new Error("Expected argument of type aggregator.CreateTaskReq");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
     function deserialize_aggregator_CreateTaskReq(buffer_arg) {
-      return avs_pb20.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateTaskResp(arg) {
-      if (!(arg instanceof avs_pb20.CreateTaskResp)) {
+      if (!(arg instanceof avs_pb22.CreateTaskResp)) {
         throw new Error("Expected argument of type aggregator.CreateTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateTaskResp(buffer_arg) {
-      return avs_pb20.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+    }
+    function serialize_aggregator_DeleteSecretReq(arg) {
+      if (!(arg instanceof avs_pb22.DeleteSecretReq)) {
+        throw new Error("Expected argument of type aggregator.DeleteSecretReq");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
+    function deserialize_aggregator_DeleteSecretReq(buffer_arg) {
+      return avs_pb22.DeleteSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_Execution(arg) {
-      if (!(arg instanceof avs_pb20.Execution)) {
+      if (!(arg instanceof avs_pb22.Execution)) {
         throw new Error("Expected argument of type aggregator.Execution");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_Execution(buffer_arg) {
-      return avs_pb20.Execution.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.Execution.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ExecutionReq(arg) {
-      if (!(arg instanceof avs_pb20.ExecutionReq)) {
+      if (!(arg instanceof avs_pb22.ExecutionReq)) {
         throw new Error("Expected argument of type aggregator.ExecutionReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ExecutionReq(buffer_arg) {
-      return avs_pb20.ExecutionReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ExecutionReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ExecutionStatusResp(arg) {
-      if (!(arg instanceof avs_pb20.ExecutionStatusResp)) {
+      if (!(arg instanceof avs_pb22.ExecutionStatusResp)) {
         throw new Error("Expected argument of type aggregator.ExecutionStatusResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ExecutionStatusResp(buffer_arg) {
-      return avs_pb20.ExecutionStatusResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ExecutionStatusResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetKeyReq(arg) {
-      if (!(arg instanceof avs_pb20.GetKeyReq)) {
+      if (!(arg instanceof avs_pb22.GetKeyReq)) {
         throw new Error("Expected argument of type aggregator.GetKeyReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetKeyReq(buffer_arg) {
-      return avs_pb20.GetKeyReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.GetKeyReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWalletReq(arg) {
-      if (!(arg instanceof avs_pb20.GetWalletReq)) {
+      if (!(arg instanceof avs_pb22.GetWalletReq)) {
         throw new Error("Expected argument of type aggregator.GetWalletReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWalletReq(buffer_arg) {
-      return avs_pb20.GetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.GetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWalletResp(arg) {
-      if (!(arg instanceof avs_pb20.GetWalletResp)) {
+      if (!(arg instanceof avs_pb22.GetWalletResp)) {
         throw new Error("Expected argument of type aggregator.GetWalletResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWalletResp(buffer_arg) {
-      return avs_pb20.GetWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.GetWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_IdReq(arg) {
-      if (!(arg instanceof avs_pb20.IdReq)) {
+      if (!(arg instanceof avs_pb22.IdReq)) {
         throw new Error("Expected argument of type aggregator.IdReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_IdReq(buffer_arg) {
-      return avs_pb20.IdReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.IdReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_KeyResp(arg) {
-      if (!(arg instanceof avs_pb20.KeyResp)) {
+      if (!(arg instanceof avs_pb22.KeyResp)) {
         throw new Error("Expected argument of type aggregator.KeyResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_KeyResp(buffer_arg) {
-      return avs_pb20.KeyResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.KeyResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListExecutionsReq(arg) {
-      if (!(arg instanceof avs_pb20.ListExecutionsReq)) {
+      if (!(arg instanceof avs_pb22.ListExecutionsReq)) {
         throw new Error("Expected argument of type aggregator.ListExecutionsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListExecutionsReq(buffer_arg) {
-      return avs_pb20.ListExecutionsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListExecutionsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListExecutionsResp(arg) {
-      if (!(arg instanceof avs_pb20.ListExecutionsResp)) {
+      if (!(arg instanceof avs_pb22.ListExecutionsResp)) {
         throw new Error("Expected argument of type aggregator.ListExecutionsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListExecutionsResp(buffer_arg) {
-      return avs_pb20.ListExecutionsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListExecutionsResp.deserializeBinary(new Uint8Array(buffer_arg));
+    }
+    function serialize_aggregator_ListSecretsReq(arg) {
+      if (!(arg instanceof avs_pb22.ListSecretsReq)) {
+        throw new Error("Expected argument of type aggregator.ListSecretsReq");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
+    function deserialize_aggregator_ListSecretsReq(buffer_arg) {
+      return avs_pb22.ListSecretsReq.deserializeBinary(new Uint8Array(buffer_arg));
+    }
+    function serialize_aggregator_ListSecretsResp(arg) {
+      if (!(arg instanceof avs_pb22.ListSecretsResp)) {
+        throw new Error("Expected argument of type aggregator.ListSecretsResp");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
+    function deserialize_aggregator_ListSecretsResp(buffer_arg) {
+      return avs_pb22.ListSecretsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListTasksReq(arg) {
-      if (!(arg instanceof avs_pb20.ListTasksReq)) {
+      if (!(arg instanceof avs_pb22.ListTasksReq)) {
         throw new Error("Expected argument of type aggregator.ListTasksReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListTasksReq(buffer_arg) {
-      return avs_pb20.ListTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListTasksResp(arg) {
-      if (!(arg instanceof avs_pb20.ListTasksResp)) {
+      if (!(arg instanceof avs_pb22.ListTasksResp)) {
         throw new Error("Expected argument of type aggregator.ListTasksResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListTasksResp(buffer_arg) {
-      return avs_pb20.ListTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListWalletReq(arg) {
-      if (!(arg instanceof avs_pb20.ListWalletReq)) {
+      if (!(arg instanceof avs_pb22.ListWalletReq)) {
         throw new Error("Expected argument of type aggregator.ListWalletReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListWalletReq(buffer_arg) {
-      return avs_pb20.ListWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListWalletResp(arg) {
-      if (!(arg instanceof avs_pb20.ListWalletResp)) {
+      if (!(arg instanceof avs_pb22.ListWalletResp)) {
         throw new Error("Expected argument of type aggregator.ListWalletResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListWalletResp(buffer_arg) {
-      return avs_pb20.ListWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_NonceRequest(arg) {
-      if (!(arg instanceof avs_pb20.NonceRequest)) {
+      if (!(arg instanceof avs_pb22.NonceRequest)) {
         throw new Error("Expected argument of type aggregator.NonceRequest");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_NonceRequest(buffer_arg) {
-      return avs_pb20.NonceRequest.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.NonceRequest.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_NonceResp(arg) {
-      if (!(arg instanceof avs_pb20.NonceResp)) {
+      if (!(arg instanceof avs_pb22.NonceResp)) {
         throw new Error("Expected argument of type aggregator.NonceResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_NonceResp(buffer_arg) {
-      return avs_pb20.NonceResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.NonceResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_Task(arg) {
-      if (!(arg instanceof avs_pb20.Task)) {
+      if (!(arg instanceof avs_pb22.Task)) {
         throw new Error("Expected argument of type aggregator.Task");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_Task(buffer_arg) {
-      return avs_pb20.Task.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.Task.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_UserTriggerTaskReq(arg) {
-      if (!(arg instanceof avs_pb20.UserTriggerTaskReq)) {
+      if (!(arg instanceof avs_pb22.UserTriggerTaskReq)) {
         throw new Error("Expected argument of type aggregator.UserTriggerTaskReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_UserTriggerTaskReq(buffer_arg) {
-      return avs_pb20.UserTriggerTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.UserTriggerTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_UserTriggerTaskResp(arg) {
-      if (!(arg instanceof avs_pb20.UserTriggerTaskResp)) {
+      if (!(arg instanceof avs_pb22.UserTriggerTaskResp)) {
         throw new Error("Expected argument of type aggregator.UserTriggerTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_UserTriggerTaskResp(buffer_arg) {
-      return avs_pb20.UserTriggerTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.UserTriggerTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_google_protobuf_BoolValue(arg) {
       if (!(arg instanceof google_protobuf_wrappers_pb.BoolValue)) {
@@ -6412,8 +7140,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetKey",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.GetKeyReq,
-        responseType: avs_pb20.KeyResp,
+        requestType: avs_pb22.GetKeyReq,
+        responseType: avs_pb22.KeyResp,
         requestSerialize: serialize_aggregator_GetKeyReq,
         requestDeserialize: deserialize_aggregator_GetKeyReq,
         responseSerialize: serialize_aggregator_KeyResp,
@@ -6424,8 +7152,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetNonce",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.NonceRequest,
-        responseType: avs_pb20.NonceResp,
+        requestType: avs_pb22.NonceRequest,
+        responseType: avs_pb22.NonceResp,
         requestSerialize: serialize_aggregator_NonceRequest,
         requestDeserialize: deserialize_aggregator_NonceRequest,
         responseSerialize: serialize_aggregator_NonceResp,
@@ -6435,8 +7163,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetWallet",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.GetWalletReq,
-        responseType: avs_pb20.GetWalletResp,
+        requestType: avs_pb22.GetWalletReq,
+        responseType: avs_pb22.GetWalletResp,
         requestSerialize: serialize_aggregator_GetWalletReq,
         requestDeserialize: deserialize_aggregator_GetWalletReq,
         responseSerialize: serialize_aggregator_GetWalletResp,
@@ -6446,8 +7174,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListWallets",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.ListWalletReq,
-        responseType: avs_pb20.ListWalletResp,
+        requestType: avs_pb22.ListWalletReq,
+        responseType: avs_pb22.ListWalletResp,
         requestSerialize: serialize_aggregator_ListWalletReq,
         requestDeserialize: deserialize_aggregator_ListWalletReq,
         responseSerialize: serialize_aggregator_ListWalletResp,
@@ -6458,8 +7186,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CreateTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.CreateTaskReq,
-        responseType: avs_pb20.CreateTaskResp,
+        requestType: avs_pb22.CreateTaskReq,
+        responseType: avs_pb22.CreateTaskResp,
         requestSerialize: serialize_aggregator_CreateTaskReq,
         requestDeserialize: deserialize_aggregator_CreateTaskReq,
         responseSerialize: serialize_aggregator_CreateTaskResp,
@@ -6469,8 +7197,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListTasks",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.ListTasksReq,
-        responseType: avs_pb20.ListTasksResp,
+        requestType: avs_pb22.ListTasksReq,
+        responseType: avs_pb22.ListTasksResp,
         requestSerialize: serialize_aggregator_ListTasksReq,
         requestDeserialize: deserialize_aggregator_ListTasksReq,
         responseSerialize: serialize_aggregator_ListTasksResp,
@@ -6480,8 +7208,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.IdReq,
-        responseType: avs_pb20.Task,
+        requestType: avs_pb22.IdReq,
+        responseType: avs_pb22.Task,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
         responseSerialize: serialize_aggregator_Task,
@@ -6491,8 +7219,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListExecutions",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.ListExecutionsReq,
-        responseType: avs_pb20.ListExecutionsResp,
+        requestType: avs_pb22.ListExecutionsReq,
+        responseType: avs_pb22.ListExecutionsResp,
         requestSerialize: serialize_aggregator_ListExecutionsReq,
         requestDeserialize: deserialize_aggregator_ListExecutionsReq,
         responseSerialize: serialize_aggregator_ListExecutionsResp,
@@ -6502,8 +7230,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecution",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.ExecutionReq,
-        responseType: avs_pb20.Execution,
+        requestType: avs_pb22.ExecutionReq,
+        responseType: avs_pb22.Execution,
         requestSerialize: serialize_aggregator_ExecutionReq,
         requestDeserialize: deserialize_aggregator_ExecutionReq,
         responseSerialize: serialize_aggregator_Execution,
@@ -6513,8 +7241,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecutionStatus",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.ExecutionReq,
-        responseType: avs_pb20.ExecutionStatusResp,
+        requestType: avs_pb22.ExecutionReq,
+        responseType: avs_pb22.ExecutionStatusResp,
         requestSerialize: serialize_aggregator_ExecutionReq,
         requestDeserialize: deserialize_aggregator_ExecutionReq,
         responseSerialize: serialize_aggregator_ExecutionStatusResp,
@@ -6524,7 +7252,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CancelTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.IdReq,
+        requestType: avs_pb22.IdReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
@@ -6535,7 +7263,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/DeleteTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.IdReq,
+        requestType: avs_pb22.IdReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
@@ -6546,42 +7274,79 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/TriggerTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb20.UserTriggerTaskReq,
-        responseType: avs_pb20.UserTriggerTaskResp,
+        requestType: avs_pb22.UserTriggerTaskReq,
+        responseType: avs_pb22.UserTriggerTaskResp,
         requestSerialize: serialize_aggregator_UserTriggerTaskReq,
         requestDeserialize: deserialize_aggregator_UserTriggerTaskReq,
         responseSerialize: serialize_aggregator_UserTriggerTaskResp,
         responseDeserialize: deserialize_aggregator_UserTriggerTaskResp
+      },
+      // CreateSecret allow you to define a secret to be used in your tasks. The secret can be used with a special syntax of ${{secrets.name }}.
+      // You can decide whether to grant secret to a single workflow or many workflow, or all of your workflow
+      // By default, your secret is available across all of your tasks.
+      createSecret: {
+        path: "/aggregator.Aggregator/CreateSecret",
+        requestStream: false,
+        responseStream: false,
+        requestType: avs_pb22.CreateOrUpdateSecretReq,
+        responseType: google_protobuf_wrappers_pb.BoolValue,
+        requestSerialize: serialize_aggregator_CreateOrUpdateSecretReq,
+        requestDeserialize: deserialize_aggregator_CreateOrUpdateSecretReq,
+        responseSerialize: serialize_google_protobuf_BoolValue,
+        responseDeserialize: deserialize_google_protobuf_BoolValue
+      },
+      deleteSecret: {
+        path: "/aggregator.Aggregator/DeleteSecret",
+        requestStream: false,
+        responseStream: false,
+        requestType: avs_pb22.DeleteSecretReq,
+        responseType: google_protobuf_wrappers_pb.BoolValue,
+        requestSerialize: serialize_aggregator_DeleteSecretReq,
+        requestDeserialize: deserialize_aggregator_DeleteSecretReq,
+        responseSerialize: serialize_google_protobuf_BoolValue,
+        responseDeserialize: deserialize_google_protobuf_BoolValue
+      },
+      // Return all secrets belong to this user. Currently we don't support any fine tune or filter yet.
+      // Only secret names and config data are returned. The secret value aren't returned.
+      listSecrets: {
+        path: "/aggregator.Aggregator/ListSecrets",
+        requestStream: false,
+        responseStream: false,
+        requestType: avs_pb22.ListSecretsReq,
+        responseType: avs_pb22.ListSecretsResp,
+        requestSerialize: serialize_aggregator_ListSecretsReq,
+        requestDeserialize: deserialize_aggregator_ListSecretsReq,
+        responseSerialize: serialize_aggregator_ListSecretsResp,
+        responseDeserialize: deserialize_aggregator_ListSecretsResp
+      },
+      // For simplicity, currently only the user who create the secrets can update its value, or update its permission.
+      // The current implementation is also limited, update is an override action, not an appending action. So when updating, you need to pass the whole payload
+      updateSecret: {
+        path: "/aggregator.Aggregator/UpdateSecret",
+        requestStream: false,
+        responseStream: false,
+        requestType: avs_pb22.CreateOrUpdateSecretReq,
+        responseType: google_protobuf_wrappers_pb.BoolValue,
+        requestSerialize: serialize_aggregator_CreateOrUpdateSecretReq,
+        requestDeserialize: deserialize_aggregator_CreateOrUpdateSecretReq,
+        responseSerialize: serialize_google_protobuf_BoolValue,
+        responseDeserialize: deserialize_google_protobuf_BoolValue
       }
     };
     exports.AggregatorClient = grpc.makeGenericClientConstructor(AggregatorService);
   }
 });
 
-// src/index.ts
-import _3 from "lodash";
-import { credentials, Metadata } from "@grpc/grpc-js";
-
-// src/auth.ts
-var getKeyRequestMessage = (chainId, address, issuedAt, expiredAt) => {
-  return `Please sign the below text for ownership verification.
-
-URI: https://app.avaprotocol.org
-Chain ID: ${chainId}
-Version: 1
-Issued At: ${issuedAt.toISOString()}
-Expire At: ${expiredAt.toISOString()}
-Wallet: ${address}`;
-};
-
 // src/index.ts
 var import_avs_grpc_pb = __toESM(require_avs_grpc_pb());
-var avs_pb19 = __toESM(require_avs_pb());
+var avs_pb21 = __toESM(require_avs_pb());
+import _4 from "lodash";
+import { credentials, Metadata } from "@grpc/grpc-js";
 import { Timestamp } from "google-protobuf/google/protobuf/timestamp_pb";
 
 // src/models/workflow.ts
-var avs_pb15 = __toESM(require_avs_pb());
-import _2 from "lodash";
+var avs_pb16 = __toESM(require_avs_pb());
+import _3 from "lodash";
 
 // src/models/edge.ts
 var avs_pb = __toESM(require_avs_pb());
@@ -6601,13 +7366,6 @@ var Edge = class _Edge {
     edge.setTarget(this.target);
     return edge;
   }
-  toJson() {
-    return {
-      id: this.id,
-      source: this.source,
-      target: this.target
-    };
-  }
 };
 var edge_default = Edge;
 
@@ -6629,14 +7387,6 @@ var Trigger = class {
   toRequest() {
     throw new Error("Method not implemented.");
   }
-  toJson() {
-    return {
-      id: this.id,
-      name: this.name,
-      type: this.type,
-      data: this.data
-    };
-  }
 };
 var interface_default = Trigger;
 
@@ -6746,17 +7496,42 @@ var EventTrigger = class _EventTrigger extends interface_default {
       throw new Error(`Trigger data is missing for ${this.type}`);
     }
     const condition = new avs_pb5.EventCondition();
-    condition.setExpression(this.data.expression);
+    const expression = this.data.expression;
+    const matcher = this.data.matcher;
+    if (expression && expression != "") {
+      condition.setExpression(expression);
+    }
+    if (matcher && matcher.length >= 1) {
+      condition.setMatcherList(matcher.map((element) => {
+        const m = new avs_pb5.EventCondition.Matcher();
+        m.setType(element["type"]);
+        m.setValueList(element["value"]);
+        return m;
+      }));
+    }
     request.setEvent(condition);
+    console.log("EventTrigger.toRequest.request:", request.toObject());
     return request;
   }
   static fromResponse(raw) {
     const obj = raw.toObject();
     console.log("EventTrigger.fromResponse.obj:", obj);
+    let data = {};
+    if (raw.getEvent().getExpression()) {
+      data.expression = raw.getEvent().getExpression();
+    }
+    if (raw.getEvent().getMatcherList()) {
+      data.matcher = raw.getEvent().getMatcherList().map((item) => {
+        return {
+          type: item.getType(),
+          value: item.getValueList()
+        };
+      });
+    }
     return new _EventTrigger({
       ...obj,
       type: "event" /* Event */,
-      data: raw.getEvent().toObject()
+      data
     });
   }
 };
@@ -6841,11 +7616,12 @@ var TriggerFactory = class {
 var factory_default = TriggerFactory;
 
 // src/models/node/factory.ts
-import _ from "lodash";
+import _2 from "lodash";
 
 // src/models/node/interface.ts
 var avs_pb7 = __toESM(require_avs_pb());
 import { NodeType } from "@avaprotocol/types";
+import _ from "lodash";
 var Node = class {
   constructor(props) {
     this.id = props.id;
@@ -6854,15 +7630,13 @@ var Node = class {
     this.data = props.data;
   }
   toRequest() {
-    throw new Error("Method not implemented.");
-  }
-  toJson() {
-    return {
-      id: this.id,
-      name: this.name,
-      type: this.type,
-      data: this.data
-    };
+    const request = new avs_pb7.TaskNode();
+    const raw = request.serializeBinary();
+    const parsed = avs_pb7.TaskNode.deserializeBinary(raw);
+    if (!_.isEqual(request, parsed)) {
+      throw new Error("Invalid request object");
+    }
+    return request;
   }
 };
 var interface_default2 = Node;
@@ -7023,7 +7797,6 @@ var ContractReadNode2 = class _ContractReadNode extends interface_default2 {
     );
     nodeData.setCallData(this.data.callData);
     nodeData.setContractAbi(this.data.contractAbi);
-    nodeData.setMethod(this.data.method);
     request.setContractRead(nodeData);
     return request;
   }
@@ -7093,31 +7866,61 @@ var BranchNode2 = class _BranchNode extends interface_default2 {
 };
 var branch_default = BranchNode2;
 
-// src/models/node/factory.ts
+// src/models/node/filter.ts
+var avs_pb15 = __toESM(require_avs_pb());
 import { NodeType as NodeType9 } from "@avaprotocol/types";
+var FilterNode2 = class _FilterNode extends interface_default2 {
+  constructor(props) {
+    super({ ...props, type: NodeType9.Filter, data: props.data });
+  }
+  static fromResponse(raw) {
+    const obj = raw.toObject();
+    return new _FilterNode({
+      ...obj,
+      type: NodeType9.Filter,
+      data: raw.getFilter().toObject()
+    });
+  }
+  toRequest() {
+    const request = new avs_pb15.TaskNode();
+    request.setId(this.id);
+    request.setName(this.name);
+    const nodeData = new avs_pb15.FilterNode();
+    nodeData.setExpression(this.data.expression);
+    nodeData.setInput(this.data.input);
+    request.setFilter(nodeData);
+    return request;
+  }
+};
+var filter_default = FilterNode2;
+
+// src/models/node/factory.ts
+import { NodeType as NodeType10 } from "@avaprotocol/types";
 var NodeFactory = class {
   static create(props) {
     switch (props.type) {
-      case NodeType9.ContractWrite:
+      case NodeType10.ContractWrite:
         return new contractWrite_default(props);
-      case NodeType9.RestAPI:
+      case NodeType10.RestAPI:
         return new restApi_default(props);
-      case NodeType9.CustomCode:
+      case NodeType10.CustomCode:
         return new customCode_default(props);
-      case NodeType9.ContractRead:
+      case NodeType10.ContractRead:
         return new contractRead_default(props);
-      case NodeType9.ETHTransfer:
+      case NodeType10.ETHTransfer:
         return new ethTransfer_default(props);
-      case NodeType9.GraphQLQuery:
+      case NodeType10.GraphQLQuery:
         return new graphqlQuery_default(props);
-      case NodeType9.Branch:
+      case NodeType10.Branch:
         return new branch_default(props);
+      case NodeType10.Filter:
+        return new filter_default(props);
       default:
         throw new Error(`Unsupported node type: ${props.type}`);
     }
   }
   static createNodes(props) {
-    return _.map(props, (node) => this.create(node));
+    return _2.map(props, (node) => this.create(node));
   }
   static fromResponse(raw) {
     switch (true) {
@@ -7135,6 +7938,8 @@ var NodeFactory = class {
         return customCode_default.fromResponse(raw);
       case !!raw.getBranch():
         return branch_default.fromResponse(raw);
+      case !!raw.getFilter():
+        return filter_default.fromResponse(raw);
       default:
         throw new Error(`Unsupported node type: ${raw.getName()}`);
     }
@@ -7145,11 +7950,11 @@ var factory_default2 = NodeFactory;
 // src/models/workflow.ts
 function convertStatusToString(status) {
   const conversionMap = {
-    [avs_pb15.TaskStatus.ACTIVE]: "active" /* Active */,
-    [avs_pb15.TaskStatus.COMPLETED]: "completed" /* Completed */,
-    [avs_pb15.TaskStatus.FAILED]: "failed" /* Failed */,
-    [avs_pb15.TaskStatus.CANCELED]: "canceled" /* Canceled */,
-    [avs_pb15.TaskStatus.EXECUTING]: "executing" /* Executing */
+    [avs_pb16.TaskStatus.ACTIVE]: "active" /* Active */,
+    [avs_pb16.TaskStatus.COMPLETED]: "completed" /* Completed */,
+    [avs_pb16.TaskStatus.FAILED]: "failed" /* Failed */,
+    [avs_pb16.TaskStatus.CANCELED]: "canceled" /* Canceled */,
+    [avs_pb16.TaskStatus.EXECUTING]: "executing" /* Executing */
   };
   return conversionMap[status];
 }
@@ -7187,11 +7992,11 @@ var Workflow = class _Workflow {
     if (!trigger) {
       throw new Error("Trigger is undefined in fromResponse()");
     }
-    const nodes = _2.map(
+    const nodes = _3.map(
       obj.getNodesList(),
       (node) => factory_default2.fromResponse(node)
     );
-    const edges = _2.map(obj.getEdgesList(), (edge) => edge_default.fromResponse(edge));
+    const edges = _3.map(obj.getEdgesList(), (edge) => edge_default.fromResponse(edge));
     const workflow = new _Workflow({
       id: obj.getId(),
       owner: obj.getOwner(),
@@ -7237,11 +8042,11 @@ var Workflow = class _Workflow {
     });
   }
   toRequest() {
-    const request = new avs_pb15.CreateTaskReq();
+    const request = new avs_pb16.CreateTaskReq();
     request.setSmartWalletAddress(this.smartWalletAddress);
     request.setTrigger(this.trigger.toRequest());
-    _2.map(this.nodes, (node) => request.addNodes(node.toRequest()));
-    _2.map(this.edges, (edge) => request.addEdges(edge.toRequest()));
+    _3.map(this.nodes, (node) => request.addNodes(node.toRequest()));
+    _3.map(this.edges, (edge) => request.addEdges(edge.toRequest()));
     request.setStartAt(this.startAt);
     request.setExpiredAt(this.expiredAt);
     request.setMaxExecution(this.maxExecution);
@@ -7254,18 +8059,18 @@ var Workflow = class _Workflow {
 var workflow_default = Workflow;
 
 // src/models/execution.ts
-var avs_pb18 = __toESM(require_avs_pb());
+var avs_pb19 = __toESM(require_avs_pb());
 
 // src/models/trigger/metadata.ts
-var avs_pb16 = __toESM(require_avs_pb());
+var avs_pb17 = __toESM(require_avs_pb());
 var convertTriggerType = (grpcType) => {
   const conversionMap = {
-    [avs_pb16.TriggerMetadata.TriggerType.FIXEDTIME]: "fixed_time" /* FixedTime */,
-    [avs_pb16.TriggerMetadata.TriggerType.CRON]: "cron" /* Cron */,
-    [avs_pb16.TriggerMetadata.TriggerType.BLOCK]: "block" /* Block */,
-    [avs_pb16.TriggerMetadata.TriggerType.EVENT]: "event" /* Event */,
-    [avs_pb16.TriggerMetadata.TriggerType.MANUAL]: "manual" /* Manual */,
-    [avs_pb16.TriggerMetadata.TriggerType.UNSET]: "unset" /* Unset */
+    [avs_pb17.TriggerMetadata.TriggerType.FIXEDTIME]: "fixed_time" /* FixedTime */,
+    [avs_pb17.TriggerMetadata.TriggerType.CRON]: "cron" /* Cron */,
+    [avs_pb17.TriggerMetadata.TriggerType.BLOCK]: "block" /* Block */,
+    [avs_pb17.TriggerMetadata.TriggerType.EVENT]: "event" /* Event */,
+    [avs_pb17.TriggerMetadata.TriggerType.MANUAL]: "manual" /* Manual */,
+    [avs_pb17.TriggerMetadata.TriggerType.UNSET]: "unset" /* Unset */
   };
   return conversionMap[grpcType];
 };
@@ -7302,28 +8107,28 @@ var TriggerMetadata2 = class _TriggerMetadata {
     });
   }
   toRequest() {
-    const request = new avs_pb16.TriggerMetadata();
+    const request = new avs_pb17.TriggerMetadata();
     switch (this.type) {
       case "fixed_time" /* FixedTime */:
-        request.setType(avs_pb16.TriggerMetadata.TriggerType.FIXEDTIME);
+        request.setType(avs_pb17.TriggerMetadata.TriggerType.FIXEDTIME);
         if (this.epoch) {
           request.setEpoch(this.epoch);
         }
         break;
       case "cron" /* Cron */:
-        request.setType(avs_pb16.TriggerMetadata.TriggerType.CRON);
+        request.setType(avs_pb17.TriggerMetadata.TriggerType.CRON);
         if (this.epoch) {
           request.setEpoch(this.epoch);
         }
         break;
       case "block" /* Block */:
-        request.setType(avs_pb16.TriggerMetadata.TriggerType.BLOCK);
+        request.setType(avs_pb17.TriggerMetadata.TriggerType.BLOCK);
         if (this.blockNumber) {
           request.setBlockNumber(this.blockNumber);
         }
         break;
       case "event" /* Event */:
-        request.setType(avs_pb16.TriggerMetadata.TriggerType.EVENT);
+        request.setType(avs_pb17.TriggerMetadata.TriggerType.EVENT);
         if (this.blockNumber) {
           request.setBlockNumber(this.blockNumber);
         }
@@ -7335,10 +8140,10 @@ var TriggerMetadata2 = class _TriggerMetadata {
         }
         break;
       case "manual" /* Manual */:
-        request.setType(avs_pb16.TriggerMetadata.TriggerType.MANUAL);
+        request.setType(avs_pb17.TriggerMetadata.TriggerType.MANUAL);
         break;
       case "unset" /* Unset */:
-        request.setType(avs_pb16.TriggerMetadata.TriggerType.UNSET);
+        request.setType(avs_pb17.TriggerMetadata.TriggerType.UNSET);
         break;
       default:
         throw new Error("Unsupported trigger type");
@@ -7349,7 +8154,7 @@ var TriggerMetadata2 = class _TriggerMetadata {
 var metadata_default = TriggerMetadata2;
 
 // src/models/step.ts
-var avs_pb17 = __toESM(require_avs_pb());
+var avs_pb18 = __toESM(require_avs_pb());
 var Step = class _Step {
   constructor(props) {
     this.nodeId = props.nodeId;
@@ -7372,7 +8177,7 @@ var Step = class _Step {
     });
   }
   toRequest() {
-    const step = new avs_pb17.Execution.Step();
+    const step = new avs_pb18.Execution.Step();
     step.setNodeId(this.nodeId);
     step.setSuccess(this.success);
     step.setOutputData(this.outputData);
@@ -7412,7 +8217,7 @@ var Execution3 = class _Execution {
     });
   }
   toRequest() {
-    const execution = new avs_pb18.Execution();
+    const execution = new avs_pb19.Execution();
     execution.setId(this.id);
     execution.setStartAt(this.startAt);
     execution.setEndAt(this.endAt);
@@ -7428,6 +8233,26 @@ var Execution3 = class _Execution {
 };
 var execution_default = Execution3;
 
+// src/models/secret.ts
+var avs_pb20 = __toESM(require_avs_pb());
+var Secret = class {
+  constructor(props) {
+    this.name = props.name;
+    this.secret = props.secret;
+    this.workflowId = props.workflowId;
+    this.orgId = props.orgId;
+  }
+  toRequest() {
+    const request = new avs_pb20.CreateOrUpdateSecretReq();
+    request.setName(this.name);
+    request.setSecret(this.secret);
+    request.setOrgId(this.orgId);
+    request.setWorkflowId(this.workflowId);
+    return request;
+  }
+};
+var secret_default = Secret;
+
 // src/index.ts
 var BaseClient = class {
   constructor(opts) {
@@ -7457,9 +8282,11 @@ var BaseClient = class {
   }
   /**
    * The API key could retrieve a wallet’s authKey by skipping its signature verification
+   * @param chainId - The chain id
    * @param address - The address of the EOA wallet
+   * @param issuedAt - The issued at timestamp
+   * @param expiredAt - The expiration timestamp
    * @param apiKey - The API key
-   * @param expiredAtEpoch - The expiration epoch
    * @returns {Promise<GetKeyResponse>} - The response from the auth call
    */
   async authWithAPIKey({
@@ -7469,7 +8296,7 @@ var BaseClient = class {
     expiredAt,
     apiKey
   }) {
-    const request = new avs_pb19.GetKeyReq();
+    const request = new avs_pb21.GetKeyReq();
     request.setChainId(chainId);
     request.setOwner(address);
     const issueTs = Timestamp.fromDate(issuedAt);
@@ -7482,9 +8309,11 @@ var BaseClient = class {
   }
   /**
    * Getting an authKey from the server by verifying the signature of an EOA wallet
+   * @param chainId - The chain id
    * @param address - The address of the EOA wallet
+   * @param issuedAt - The issued at timestamp
+   * @param expiredAt - The expiration timestamp
    * @param signature - The signature of the EOA wallet
-   * @param expiredAtEpoch - The expiration epoch
    * @returns {Promise<GetKeyResponse>} - The response from the auth call
    */
   async authWithSignature({
@@ -7494,7 +8323,7 @@ var BaseClient = class {
     expiredAt,
     signature
   }) {
-    const request = new avs_pb19.GetKeyReq();
+    const request = new avs_pb21.GetKeyReq();
     request.setChainId(chainId);
     request.setOwner(address);
     const issueTs = Timestamp.fromDate(issuedAt);
@@ -7545,7 +8374,7 @@ var BaseClient = class {
    * @returns {Promise<TResponse>} - The response from the gRPC call
    */
   sendGrpcRequest(method, request, options) {
-    const metadata = _3.cloneDeep(this.metadata);
+    const metadata = _4.cloneDeep(this.metadata);
     if (options?.authKey) {
       metadata.set(AUTH_KEY_HEADER, options.authKey);
     } else if (this.authKey) {
@@ -7573,7 +8402,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<SmartWallet[]>} - The list of SmartWallet objects
    */
   async getWallets(options) {
-    const request = new avs_pb19.ListWalletReq();
+    const request = new avs_pb21.ListWalletReq();
     const result = await this.sendGrpcRequest("listWallets", request, options);
     return result.getItemsList().map((item) => item.toObject());
   }
@@ -7585,7 +8414,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<SmartWallet>} - The added SmartWallet object
    */
   async getWallet({ salt, factoryAddress }, options) {
-    const request = new avs_pb19.GetWalletReq();
+    const request = new avs_pb21.GetWalletReq();
     request.setSalt(salt);
     if (factoryAddress) {
       request.setFactoryAddress(factoryAddress);
@@ -7596,7 +8425,12 @@ var Client = class extends BaseClient {
     return {
       address: result.getAddress(),
       salt: result.getSalt(),
-      factory: result.getFactoryAddress()
+      factory: result.getFactoryAddress(),
+      totalTaskCount: result.getTotalTaskCount(),
+      activeTaskCount: result.getActiveTaskCount(),
+      completedTaskCount: result.getCompletedTaskCount(),
+      failedTaskCount: result.getFailedTaskCount(),
+      canceledTaskCount: result.getCanceledTaskCount()
     };
   }
   /**
@@ -7622,7 +8456,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ cursor: string; result: Workflow[] }>} - The list of Workflow objects
    */
   async getWorkflows(addresses, options) {
-    const request = new avs_pb19.ListTasksReq();
+    const request = new avs_pb21.ListTasksReq();
     for (const a of addresses) {
       request.addSmartWalletAddress(a);
     }
@@ -7647,7 +8481,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ cursor: string; result: Execution[] }>} - The list of Executions
    */
   async getExecutions(workflows, options) {
-    const request = new avs_pb19.ListExecutionsReq();
+    const request = new avs_pb21.ListExecutionsReq();
     request.setTaskIdsList(workflows);
     if (options?.cursor && options?.cursor != "") {
       request.setCursor(options.cursor);
@@ -7668,7 +8502,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<Execution>} - The result execution if it is existed
    */
   async getExecution(taskId, executionId, options) {
-    const request = new avs_pb19.ExecutionReq();
+    const request = new avs_pb21.ExecutionReq();
     request.setTaskId(taskId);
     request.setExecutionId(executionId);
     const result = await this.sendGrpcRequest("getExecution", request, options);
@@ -7685,7 +8519,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<ExecutionStatus>} - The result execution if it is existed
    */
   async getExecutionStatus(taskId, executionId, options) {
-    const request = new avs_pb19.ExecutionReq();
+    const request = new avs_pb21.ExecutionReq();
     request.setTaskId(taskId);
     request.setExecutionId(executionId);
     const result = await this.sendGrpcRequest("getExecutionStatus", request, options);
@@ -7698,7 +8532,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<Workflow>} - The Workflow object
    */
   async getWorkflow(id, options) {
-    const request = new avs_pb19.IdReq();
+    const request = new avs_pb21.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "getTask",
@@ -7720,7 +8554,7 @@ var Client = class extends BaseClient {
     data,
     isBlocking = false
   }, options) {
-    const request = new avs_pb19.UserTriggerTaskReq();
+    const request = new avs_pb21.UserTriggerTaskReq();
     request.setTaskId(id);
     request.setTriggerMetadata(new metadata_default(data).toRequest());
     request.setIsBlocking(isBlocking);
@@ -7734,7 +8568,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - Whether the workflow was successfully canceled
    */
   async cancelWorkflow(id, options) {
-    const request = new avs_pb19.IdReq();
+    const request = new avs_pb21.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "cancelTask",
@@ -7750,7 +8584,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - Whether the workflow was successfully deleted
    */
   async deleteWorkflow(id, options) {
-    const request = new avs_pb19.IdReq();
+    const request = new avs_pb21.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "deleteTask",
@@ -7759,6 +8593,39 @@ var Client = class extends BaseClient {
     );
     return result.getValue();
   }
+  async createSecret(secret, options) {
+    const request = secret.toRequest();
+    const result = await this.sendGrpcRequest("createSecret", request, options);
+    return result.getValue();
+  }
+  async listSecrets(params, options) {
+    const request = new avs_pb21.ListSecretsReq();
+    if (params?.workflowId) {
+      request.setWorkflowId(params.workflowId);
+    }
+    const result = await this.sendGrpcRequest("listSecrets", request, options);
+    return result.getItemsList().map((item) => {
+      return {
+        name: item.getName(),
+        workflowId: item.getWorkflowId(),
+        orgId: item.getOrgId()
+      };
+    });
+  }
+  async deleteSecret(params, options) {
+    const request = new avs_pb21.DeleteSecretReq();
+    request.setName(params.name);
+    if (params?.workflowId) {
+      request.setWorkflowId(params.workflowId);
+    }
+    const result = await this.sendGrpcRequest("deleteSecret", request, options);
+    return result.getValue();
+  }
+  async updateSecret(secret, options) {
+    const request = secret.toRequest();
+    const result = await this.sendGrpcRequest("updateSecret", request, options);
+    return result.getValue();
+  }
 };
 export {
   AUTH_KEY_HEADER,
@@ -7775,16 +8642,17 @@ export {
   event_default as EventTrigger,
   execution_default as Execution,
   ExecutionStatus2 as ExecutionStatus,
+  filter_default as FilterNode,
   fixedTime_default as FixedTimeTrigger,
   graphqlQuery_default as GraphQLQueryNode,
   interface_default2 as Node,
   factory_default2 as NodeFactory,
   restApi_default as RestAPINode,
+  secret_default as Secret,
   interface_default as Trigger,
   factory_default as TriggerFactory,
   TriggerType,
   workflow_default as Workflow,
   WorkflowStatus,
-  Client as default,
-  getKeyRequestMessage
+  Client as default
 };