@avaprotocol/sdk-js 1.3.4-dev.1 → 1.3.4-dev.3

package/dist/index.js

@@ -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);
@@ -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);
@@ -1184,7 +1224,8 @@ 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, "")
+          contractAbi: jspb.Message.getFieldWithDefault(msg, 3, ""),
+          method: jspb.Message.getFieldWithDefault(msg, 4, "")
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -1225,6 +1266,13 @@ 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;
@@ -1260,6 +1308,13 @@ var require_avs_pb = __commonJS({
           f
         );
       }
+      f = message.getMethod();
+      if (f.length > 0) {
+        writer.writeString(
+          4,
+          f
+        );
+      }
     };
     proto.aggregator.ContractWriteNode.prototype.getContractAddress = function() {
       return (
@@ -1288,6 +1343,15 @@ var require_avs_pb = __commonJS({
     proto.aggregator.ContractWriteNode.prototype.setContractAbi = function(value) {
       return jspb.Message.setProto3StringField(this, 3, value);
     };
+    proto.aggregator.ContractWriteNode.prototype.getMethod = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 4, "")
+      );
+    };
+    proto.aggregator.ContractWriteNode.prototype.setMethod = function(value) {
+      return jspb.Message.setProto3StringField(this, 4, value);
+    };
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.ContractReadNode.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.ContractReadNode.toObject(opt_includeInstance, this);
@@ -5862,7 +5926,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 +5972,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 +6042,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 +6105,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 +6355,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(exports2, proto.aggregator);
-  }
-});
-
-// ../../grpc_codegen/avs_grpc_pb.js
-var require_avs_grpc_pb = __commonJS({
-  "../../grpc_codegen/avs_grpc_pb.js"(exports2) {
-    "use strict";
-    var grpc2 = 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());
-    }
-    function deserialize_aggregator_CreateTaskReq(buffer_arg) {
-      return avs_pb20.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
-    }
-    function serialize_aggregator_CreateTaskResp(arg) {
-      if (!(arg instanceof avs_pb20.CreateTaskResp)) {
-        throw new Error("Expected argument of type aggregator.CreateTaskResp");
+      f = message.getSecret();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
       }
-      return Buffer.from(arg.serializeBinary());
-    }
-    function deserialize_aggregator_CreateTaskResp(buffer_arg) {
-      return avs_pb20.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
-    }
-    function serialize_aggregator_Execution(arg) {
-      if (!(arg instanceof avs_pb20.Execution)) {
-        throw new Error("Expected argument of type aggregator.Execution");
+      f = message.getWorkflowId();
+      if (f.length > 0) {
+        writer.writeString(
+          3,
+          f
+        );
       }
-      return Buffer.from(arg.serializeBinary());
-    }
-    function deserialize_aggregator_Execution(buffer_arg) {
-      return avs_pb20.Execution.deserializeBinary(new Uint8Array(buffer_arg));
-    }
-    function serialize_aggregator_ExecutionReq(arg) {
-      if (!(arg instanceof avs_pb20.ExecutionReq)) {
+      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(exports2, proto.aggregator);
+  }
+});
+
+// ../../grpc_codegen/avs_grpc_pb.js
+var require_avs_grpc_pb = __commonJS({
+  "../../grpc_codegen/avs_grpc_pb.js"(exports2) {
+    "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_pb22.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+    }
+    function serialize_aggregator_CreateTaskResp(arg) {
+      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_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_pb22.Execution)) {
+        throw new Error("Expected argument of type aggregator.Execution");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
+    function deserialize_aggregator_Execution(buffer_arg) {
+      return avs_pb22.Execution.deserializeBinary(new Uint8Array(buffer_arg));
+    }
+    function serialize_aggregator_ExecutionReq(arg) {
+      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 +7154,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 +7166,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 +7177,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 +7188,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 +7200,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 +7211,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 +7222,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 +7233,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 +7244,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 +7255,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 +7266,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 +7277,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,15 +7288,66 @@ 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
       }
     };
-    exports2.AggregatorClient = grpc2.makeGenericClientConstructor(AggregatorService);
+    exports2.AggregatorClient = grpc.makeGenericClientConstructor(AggregatorService);
   }
 });
 
@@ -6575,11 +7368,13 @@ __export(index_exports, {
   EventTrigger: () => event_default,
   Execution: () => execution_default,
   ExecutionStatus: () => ExecutionStatus2,
+  FilterNode: () => filter_default,
   FixedTimeTrigger: () => fixedTime_default,
   GraphQLQueryNode: () => graphqlQuery_default,
   Node: () => interface_default2,
   NodeFactory: () => factory_default2,
   RestAPINode: () => restApi_default,
+  Secret: () => secret_default,
   Trigger: () => interface_default,
   TriggerFactory: () => factory_default,
   TriggerType: () => TriggerType,
@@ -6590,7 +7385,6 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_lodash3 = __toESM(require("lodash"));
-var grpc = __toESM(require("@grpc/grpc-js"));
 var import_grpc_js = require("@grpc/grpc-js");
 
 // src/auth.ts
@@ -6600,19 +7394,19 @@ var getKeyRequestMessage = (chainId, address, issuedAt, expiredAt) => {
 URI: https://app.avaprotocol.org
 Chain ID: ${chainId}
 Version: 1
-Issued At: ${issuedAt.toISOString()}
-Expire At: ${expiredAt.toISOString()}
+Issued At: ${issuedAt}
+Expire At: ${expiredAt}
 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());
 var import_timestamp_pb = require("google-protobuf/google/protobuf/timestamp_pb");
 
 // src/models/workflow.ts
 var import_lodash2 = __toESM(require("lodash"));
-var avs_pb15 = __toESM(require_avs_pb());
+var avs_pb16 = __toESM(require_avs_pb());
 
 // src/models/edge.ts
 var avs_pb = __toESM(require_avs_pb());
@@ -6923,6 +7717,7 @@ var ContractWriteNode2 = class _ContractWriteNode extends interface_default2 {
     );
     nodeData.setCallData(this.data.callData);
     nodeData.setContractAbi(this.data.contractAbi);
+    nodeData.setMethod(this.data.method);
     request.setContractWrite(nodeData);
     return request;
   }
@@ -7124,25 +7919,55 @@ 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());
 var import_types14 = require("@avaprotocol/types");
+var FilterNode2 = class _FilterNode extends interface_default2 {
+  constructor(props) {
+    super({ ...props, type: import_types14.NodeType.Filter, data: props.data });
+  }
+  static fromResponse(raw) {
+    const obj = raw.toObject();
+    return new _FilterNode({
+      ...obj,
+      type: import_types14.NodeType.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
+var import_types15 = require("@avaprotocol/types");
 var NodeFactory = class {
   static create(props) {
     switch (props.type) {
-      case import_types14.NodeType.ContractWrite:
+      case import_types15.NodeType.ContractWrite:
         return new contractWrite_default(props);
-      case import_types14.NodeType.RestAPI:
+      case import_types15.NodeType.RestAPI:
         return new restApi_default(props);
-      case import_types14.NodeType.CustomCode:
+      case import_types15.NodeType.CustomCode:
         return new customCode_default(props);
-      case import_types14.NodeType.ContractRead:
+      case import_types15.NodeType.ContractRead:
         return new contractRead_default(props);
-      case import_types14.NodeType.ETHTransfer:
+      case import_types15.NodeType.ETHTransfer:
         return new ethTransfer_default(props);
-      case import_types14.NodeType.GraphQLQuery:
+      case import_types15.NodeType.GraphQLQuery:
         return new graphqlQuery_default(props);
-      case import_types14.NodeType.Branch:
+      case import_types15.NodeType.Branch:
         return new branch_default(props);
+      case import_types15.NodeType.Filter:
+        return new filter_default(props);
       default:
         throw new Error(`Unsupported node type: ${props.type}`);
     }
@@ -7166,6 +7991,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()}`);
     }
@@ -7176,11 +8003,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];
 }
@@ -7268,7 +8095,7 @@ 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());
     import_lodash2.default.map(this.nodes, (node) => request.addNodes(node.toRequest()));
@@ -7285,18 +8112,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];
 };
@@ -7333,28 +8160,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);
         }
@@ -7366,10 +8193,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");
@@ -7380,7 +8207,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;
@@ -7403,7 +8230,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);
@@ -7443,7 +8270,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);
@@ -7459,13 +8286,33 @@ 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) {
     this.endpoint = opts.endpoint;
     this.rpcClient = new import_avs_grpc_pb.AggregatorClient(
       this.endpoint,
-      grpc.credentials.createInsecure()
+      import_grpc_js.credentials.createInsecure()
     );
     this.factoryAddress = opts.factoryAddress;
     this.metadata = new import_grpc_js.Metadata();
@@ -7500,7 +8347,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 = import_timestamp_pb.Timestamp.fromDate(issuedAt);
@@ -7525,7 +8372,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 = import_timestamp_pb.Timestamp.fromDate(issuedAt);
@@ -7604,7 +8451,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());
   }
@@ -7616,7 +8463,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);
@@ -7627,7 +8474,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()
     };
   }
   /**
@@ -7653,7 +8505,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);
     }
@@ -7678,7 +8530,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);
@@ -7699,7 +8551,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);
@@ -7716,7 +8568,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);
@@ -7729,7 +8581,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",
@@ -7751,7 +8603,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);
@@ -7765,7 +8617,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",
@@ -7781,7 +8633,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",
@@ -7790,6 +8642,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();
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -7807,11 +8692,13 @@ var Client = class extends BaseClient {
   EventTrigger,
   Execution,
   ExecutionStatus,
+  FilterNode,
   FixedTimeTrigger,
   GraphQLQueryNode,
   Node,
   NodeFactory,
   RestAPINode,
+  Secret,
   Trigger,
   TriggerFactory,
   TriggerType,