@avaprotocol/sdk-js 2.7.0 → 2.7.2

package/dist/index.js

@@ -7008,8 +7008,9 @@ var require_avs_pb = __commonJS({
           id: jspb.Message.getFieldWithDefault(msg, 1, ""),
           startAt: jspb.Message.getFieldWithDefault(msg, 2, 0),
           endAt: jspb.Message.getFieldWithDefault(msg, 3, 0),
-          success: jspb.Message.getBooleanFieldWithDefault(msg, 4, false),
+          status: jspb.Message.getFieldWithDefault(msg, 4, 0),
           error: jspb.Message.getFieldWithDefault(msg, 5, ""),
+          index: jspb.Message.getFieldWithDefault(msg, 6, 0),
           stepsList: jspb.Message.toObjectList(
             msg.getStepsList(),
             proto.aggregator.Execution.Step.toObject,
@@ -7057,10 +7058,10 @@ var require_avs_pb = __commonJS({
             break;
           case 4:
             var value = (
-              /** @type {boolean} */
-              reader.readBool()
+              /** @type {!proto.aggregator.ExecutionStatus} */
+              reader.readEnum()
             );
-            msg.setSuccess(value);
+            msg.setStatus(value);
             break;
           case 5:
             var value = (
@@ -7069,6 +7070,13 @@ var require_avs_pb = __commonJS({
             );
             msg.setError(value);
             break;
+          case 6:
+            var value = (
+              /** @type {number} */
+              reader.readInt64()
+            );
+            msg.setIndex(value);
+            break;
           case 8:
             var value = new proto.aggregator.Execution.Step();
             reader.readMessage(value, proto.aggregator.Execution.Step.deserializeBinaryFromReader);
@@ -7109,9 +7117,9 @@ var require_avs_pb = __commonJS({
           f
         );
       }
-      f = message.getSuccess();
-      if (f) {
-        writer.writeBool(
+      f = message.getStatus();
+      if (f !== 0) {
+        writer.writeEnum(
           4,
           f
         );
@@ -7123,6 +7131,13 @@ var require_avs_pb = __commonJS({
           f
         );
       }
+      f = message.getIndex();
+      if (f !== 0) {
+        writer.writeInt64(
+          6,
+          f
+        );
+      }
       f = message.getStepsList();
       if (f.length > 0) {
         writer.writeRepeatedMessage(
@@ -7939,14 +7954,14 @@ var require_avs_pb = __commonJS({
     proto.aggregator.Execution.prototype.setEndAt = function(value) {
       return jspb.Message.setProto3IntField(this, 3, value);
     };
-    proto.aggregator.Execution.prototype.getSuccess = function() {
+    proto.aggregator.Execution.prototype.getStatus = function() {
       return (
-        /** @type {boolean} */
-        jspb.Message.getBooleanFieldWithDefault(this, 4, false)
+        /** @type {!proto.aggregator.ExecutionStatus} */
+        jspb.Message.getFieldWithDefault(this, 4, 0)
       );
     };
-    proto.aggregator.Execution.prototype.setSuccess = function(value) {
-      return jspb.Message.setProto3BooleanField(this, 4, value);
+    proto.aggregator.Execution.prototype.setStatus = function(value) {
+      return jspb.Message.setProto3EnumField(this, 4, value);
     };
     proto.aggregator.Execution.prototype.getError = function() {
       return (
@@ -7957,6 +7972,15 @@ var require_avs_pb = __commonJS({
     proto.aggregator.Execution.prototype.setError = function(value) {
       return jspb.Message.setProto3StringField(this, 5, value);
     };
+    proto.aggregator.Execution.prototype.getIndex = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 6, 0)
+      );
+    };
+    proto.aggregator.Execution.prototype.setIndex = function(value) {
+      return jspb.Message.setProto3IntField(this, 6, value);
+    };
     proto.aggregator.Execution.prototype.getStepsList = function() {
       return (
         /** @type{!Array<!proto.aggregator.Execution.Step>} */
@@ -11190,7 +11214,6 @@ var require_avs_pb = __commonJS({
           workflowId: jspb.Message.getFieldWithDefault(msg, 3, ""),
           startAt: jspb.Message.getFieldWithDefault(msg, 4, 0),
           endAt: jspb.Message.getFieldWithDefault(msg, 5, 0),
-          success: jspb.Message.getBooleanFieldWithDefault(msg, 6, false),
           error: jspb.Message.getFieldWithDefault(msg, 7, ""),
           stepsList: jspb.Message.toObjectList(
             msg.getStepsList(),
@@ -11251,13 +11274,6 @@ var require_avs_pb = __commonJS({
             );
             msg.setEndAt(value);
             break;
-          case 6:
-            var value = (
-              /** @type {boolean} */
-              reader.readBool()
-            );
-            msg.setSuccess(value);
-            break;
           case 7:
             var value = (
               /** @type {string} */
@@ -11321,14 +11337,6 @@ var require_avs_pb = __commonJS({
           f
         );
       }
-      f = /** @type {boolean} */
-      jspb.Message.getField(message, 6);
-      if (f != null) {
-        writer.writeBool(
-          6,
-          f
-        );
-      }
       f = /** @type {string} */
       jspb.Message.getField(message, 7);
       if (f != null) {
@@ -11403,21 +11411,6 @@ var require_avs_pb = __commonJS({
     proto.aggregator.TriggerTaskResp.prototype.hasEndAt = function() {
       return jspb.Message.getField(this, 5) != null;
     };
-    proto.aggregator.TriggerTaskResp.prototype.getSuccess = function() {
-      return (
-        /** @type {boolean} */
-        jspb.Message.getBooleanFieldWithDefault(this, 6, false)
-      );
-    };
-    proto.aggregator.TriggerTaskResp.prototype.setSuccess = function(value) {
-      return jspb.Message.setField(this, 6, value);
-    };
-    proto.aggregator.TriggerTaskResp.prototype.clearSuccess = function() {
-      return jspb.Message.setField(this, 6, void 0);
-    };
-    proto.aggregator.TriggerTaskResp.prototype.hasSuccess = function() {
-      return jspb.Message.getField(this, 6) != null;
-    };
     proto.aggregator.TriggerTaskResp.prototype.getError = function() {
       return (
         /** @type {string} */
@@ -15264,8 +15257,9 @@ var require_avs_pb = __commonJS({
     proto.aggregator.ExecutionStatus = {
       EXECUTION_STATUS_UNSPECIFIED: 0,
       EXECUTION_STATUS_PENDING: 1,
-      EXECUTION_STATUS_COMPLETED: 2,
-      EXECUTION_STATUS_FAILED: 3
+      EXECUTION_STATUS_SUCCESS: 2,
+      EXECUTION_STATUS_FAILED: 3,
+      EXECUTION_STATUS_PARTIAL_SUCCESS: 4
     };
     goog.object.extend(exports2, proto.aggregator);
   }
@@ -15276,439 +15270,439 @@ var require_avs_grpc_pb = __commonJS({
   "../../grpc_codegen/avs_grpc_pb.js"(exports2) {
     "use strict";
     var grpc = require("@grpc/grpc-js");
-    var avs_pb23 = require_avs_pb();
+    var avs_pb24 = require_avs_pb();
     var google_protobuf_struct_pb5 = require("google-protobuf/google/protobuf/struct_pb.js");
     function serialize_aggregator_CancelTaskResp(arg) {
-      if (!(arg instanceof avs_pb23.CancelTaskResp)) {
+      if (!(arg instanceof avs_pb24.CancelTaskResp)) {
         throw new Error("Expected argument of type aggregator.CancelTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CancelTaskResp(buffer_arg) {
-      return avs_pb23.CancelTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.CancelTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateOrUpdateSecretReq(arg) {
-      if (!(arg instanceof avs_pb23.CreateOrUpdateSecretReq)) {
+      if (!(arg instanceof avs_pb24.CreateOrUpdateSecretReq)) {
         throw new Error("Expected argument of type aggregator.CreateOrUpdateSecretReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateOrUpdateSecretReq(buffer_arg) {
-      return avs_pb23.CreateOrUpdateSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.CreateOrUpdateSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateSecretResp(arg) {
-      if (!(arg instanceof avs_pb23.CreateSecretResp)) {
+      if (!(arg instanceof avs_pb24.CreateSecretResp)) {
         throw new Error("Expected argument of type aggregator.CreateSecretResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateSecretResp(buffer_arg) {
-      return avs_pb23.CreateSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.CreateSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateTaskReq(arg) {
-      if (!(arg instanceof avs_pb23.CreateTaskReq)) {
+      if (!(arg instanceof avs_pb24.CreateTaskReq)) {
         throw new Error("Expected argument of type aggregator.CreateTaskReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateTaskReq(buffer_arg) {
-      return avs_pb23.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateTaskResp(arg) {
-      if (!(arg instanceof avs_pb23.CreateTaskResp)) {
+      if (!(arg instanceof avs_pb24.CreateTaskResp)) {
         throw new Error("Expected argument of type aggregator.CreateTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateTaskResp(buffer_arg) {
-      return avs_pb23.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_DeleteSecretReq(arg) {
-      if (!(arg instanceof avs_pb23.DeleteSecretReq)) {
+      if (!(arg instanceof avs_pb24.DeleteSecretReq)) {
         throw new Error("Expected argument of type aggregator.DeleteSecretReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_DeleteSecretReq(buffer_arg) {
-      return avs_pb23.DeleteSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.DeleteSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_DeleteSecretResp(arg) {
-      if (!(arg instanceof avs_pb23.DeleteSecretResp)) {
+      if (!(arg instanceof avs_pb24.DeleteSecretResp)) {
         throw new Error("Expected argument of type aggregator.DeleteSecretResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_DeleteSecretResp(buffer_arg) {
-      return avs_pb23.DeleteSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.DeleteSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_DeleteTaskResp(arg) {
-      if (!(arg instanceof avs_pb23.DeleteTaskResp)) {
+      if (!(arg instanceof avs_pb24.DeleteTaskResp)) {
         throw new Error("Expected argument of type aggregator.DeleteTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_DeleteTaskResp(buffer_arg) {
-      return avs_pb23.DeleteTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.DeleteTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_Execution(arg) {
-      if (!(arg instanceof avs_pb23.Execution)) {
+      if (!(arg instanceof avs_pb24.Execution)) {
         throw new Error("Expected argument of type aggregator.Execution");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_Execution(buffer_arg) {
-      return avs_pb23.Execution.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.Execution.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ExecutionReq(arg) {
-      if (!(arg instanceof avs_pb23.ExecutionReq)) {
+      if (!(arg instanceof avs_pb24.ExecutionReq)) {
         throw new Error("Expected argument of type aggregator.ExecutionReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ExecutionReq(buffer_arg) {
-      return avs_pb23.ExecutionReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.ExecutionReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ExecutionStatusResp(arg) {
-      if (!(arg instanceof avs_pb23.ExecutionStatusResp)) {
+      if (!(arg instanceof avs_pb24.ExecutionStatusResp)) {
         throw new Error("Expected argument of type aggregator.ExecutionStatusResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ExecutionStatusResp(buffer_arg) {
-      return avs_pb23.ExecutionStatusResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.ExecutionStatusResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionCountReq(arg) {
-      if (!(arg instanceof avs_pb23.GetExecutionCountReq)) {
+      if (!(arg instanceof avs_pb24.GetExecutionCountReq)) {
         throw new Error("Expected argument of type aggregator.GetExecutionCountReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetExecutionCountReq(buffer_arg) {
-      return avs_pb23.GetExecutionCountReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetExecutionCountReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionCountResp(arg) {
-      if (!(arg instanceof avs_pb23.GetExecutionCountResp)) {
+      if (!(arg instanceof avs_pb24.GetExecutionCountResp)) {
         throw new Error("Expected argument of type aggregator.GetExecutionCountResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetExecutionCountResp(buffer_arg) {
-      return avs_pb23.GetExecutionCountResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetExecutionCountResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionStatsReq(arg) {
-      if (!(arg instanceof avs_pb23.GetExecutionStatsReq)) {
+      if (!(arg instanceof avs_pb24.GetExecutionStatsReq)) {
         throw new Error("Expected argument of type aggregator.GetExecutionStatsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetExecutionStatsReq(buffer_arg) {
-      return avs_pb23.GetExecutionStatsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetExecutionStatsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionStatsResp(arg) {
-      if (!(arg instanceof avs_pb23.GetExecutionStatsResp)) {
+      if (!(arg instanceof avs_pb24.GetExecutionStatsResp)) {
         throw new Error("Expected argument of type aggregator.GetExecutionStatsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetExecutionStatsResp(buffer_arg) {
-      return avs_pb23.GetExecutionStatsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetExecutionStatsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetKeyReq(arg) {
-      if (!(arg instanceof avs_pb23.GetKeyReq)) {
+      if (!(arg instanceof avs_pb24.GetKeyReq)) {
         throw new Error("Expected argument of type aggregator.GetKeyReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetKeyReq(buffer_arg) {
-      return avs_pb23.GetKeyReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetKeyReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetSignatureFormatReq(arg) {
-      if (!(arg instanceof avs_pb23.GetSignatureFormatReq)) {
+      if (!(arg instanceof avs_pb24.GetSignatureFormatReq)) {
         throw new Error("Expected argument of type aggregator.GetSignatureFormatReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetSignatureFormatReq(buffer_arg) {
-      return avs_pb23.GetSignatureFormatReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetSignatureFormatReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetSignatureFormatResp(arg) {
-      if (!(arg instanceof avs_pb23.GetSignatureFormatResp)) {
+      if (!(arg instanceof avs_pb24.GetSignatureFormatResp)) {
         throw new Error("Expected argument of type aggregator.GetSignatureFormatResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetSignatureFormatResp(buffer_arg) {
-      return avs_pb23.GetSignatureFormatResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetSignatureFormatResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetTokenMetadataReq(arg) {
-      if (!(arg instanceof avs_pb23.GetTokenMetadataReq)) {
+      if (!(arg instanceof avs_pb24.GetTokenMetadataReq)) {
         throw new Error("Expected argument of type aggregator.GetTokenMetadataReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetTokenMetadataReq(buffer_arg) {
-      return avs_pb23.GetTokenMetadataReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetTokenMetadataReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetTokenMetadataResp(arg) {
-      if (!(arg instanceof avs_pb23.GetTokenMetadataResp)) {
+      if (!(arg instanceof avs_pb24.GetTokenMetadataResp)) {
         throw new Error("Expected argument of type aggregator.GetTokenMetadataResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetTokenMetadataResp(buffer_arg) {
-      return avs_pb23.GetTokenMetadataResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetTokenMetadataResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWalletReq(arg) {
-      if (!(arg instanceof avs_pb23.GetWalletReq)) {
+      if (!(arg instanceof avs_pb24.GetWalletReq)) {
         throw new Error("Expected argument of type aggregator.GetWalletReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWalletReq(buffer_arg) {
-      return avs_pb23.GetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWalletResp(arg) {
-      if (!(arg instanceof avs_pb23.GetWalletResp)) {
+      if (!(arg instanceof avs_pb24.GetWalletResp)) {
         throw new Error("Expected argument of type aggregator.GetWalletResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWalletResp(buffer_arg) {
-      return avs_pb23.GetWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWorkflowCountReq(arg) {
-      if (!(arg instanceof avs_pb23.GetWorkflowCountReq)) {
+      if (!(arg instanceof avs_pb24.GetWorkflowCountReq)) {
         throw new Error("Expected argument of type aggregator.GetWorkflowCountReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWorkflowCountReq(buffer_arg) {
-      return avs_pb23.GetWorkflowCountReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetWorkflowCountReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWorkflowCountResp(arg) {
-      if (!(arg instanceof avs_pb23.GetWorkflowCountResp)) {
+      if (!(arg instanceof avs_pb24.GetWorkflowCountResp)) {
         throw new Error("Expected argument of type aggregator.GetWorkflowCountResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWorkflowCountResp(buffer_arg) {
-      return avs_pb23.GetWorkflowCountResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.GetWorkflowCountResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_IdReq(arg) {
-      if (!(arg instanceof avs_pb23.IdReq)) {
+      if (!(arg instanceof avs_pb24.IdReq)) {
         throw new Error("Expected argument of type aggregator.IdReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_IdReq(buffer_arg) {
-      return avs_pb23.IdReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.IdReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_KeyResp(arg) {
-      if (!(arg instanceof avs_pb23.KeyResp)) {
+      if (!(arg instanceof avs_pb24.KeyResp)) {
         throw new Error("Expected argument of type aggregator.KeyResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_KeyResp(buffer_arg) {
-      return avs_pb23.KeyResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.KeyResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListExecutionsReq(arg) {
-      if (!(arg instanceof avs_pb23.ListExecutionsReq)) {
+      if (!(arg instanceof avs_pb24.ListExecutionsReq)) {
         throw new Error("Expected argument of type aggregator.ListExecutionsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListExecutionsReq(buffer_arg) {
-      return avs_pb23.ListExecutionsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.ListExecutionsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListExecutionsResp(arg) {
-      if (!(arg instanceof avs_pb23.ListExecutionsResp)) {
+      if (!(arg instanceof avs_pb24.ListExecutionsResp)) {
         throw new Error("Expected argument of type aggregator.ListExecutionsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListExecutionsResp(buffer_arg) {
-      return avs_pb23.ListExecutionsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.ListExecutionsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListSecretsReq(arg) {
-      if (!(arg instanceof avs_pb23.ListSecretsReq)) {
+      if (!(arg instanceof avs_pb24.ListSecretsReq)) {
         throw new Error("Expected argument of type aggregator.ListSecretsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListSecretsReq(buffer_arg) {
-      return avs_pb23.ListSecretsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.ListSecretsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListSecretsResp(arg) {
-      if (!(arg instanceof avs_pb23.ListSecretsResp)) {
+      if (!(arg instanceof avs_pb24.ListSecretsResp)) {
         throw new Error("Expected argument of type aggregator.ListSecretsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListSecretsResp(buffer_arg) {
-      return avs_pb23.ListSecretsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.ListSecretsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListTasksReq(arg) {
-      if (!(arg instanceof avs_pb23.ListTasksReq)) {
+      if (!(arg instanceof avs_pb24.ListTasksReq)) {
         throw new Error("Expected argument of type aggregator.ListTasksReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListTasksReq(buffer_arg) {
-      return avs_pb23.ListTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.ListTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListTasksResp(arg) {
-      if (!(arg instanceof avs_pb23.ListTasksResp)) {
+      if (!(arg instanceof avs_pb24.ListTasksResp)) {
         throw new Error("Expected argument of type aggregator.ListTasksResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListTasksResp(buffer_arg) {
-      return avs_pb23.ListTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.ListTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListWalletReq(arg) {
-      if (!(arg instanceof avs_pb23.ListWalletReq)) {
+      if (!(arg instanceof avs_pb24.ListWalletReq)) {
         throw new Error("Expected argument of type aggregator.ListWalletReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListWalletReq(buffer_arg) {
-      return avs_pb23.ListWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.ListWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListWalletResp(arg) {
-      if (!(arg instanceof avs_pb23.ListWalletResp)) {
+      if (!(arg instanceof avs_pb24.ListWalletResp)) {
         throw new Error("Expected argument of type aggregator.ListWalletResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListWalletResp(buffer_arg) {
-      return avs_pb23.ListWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.ListWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_NonceRequest(arg) {
-      if (!(arg instanceof avs_pb23.NonceRequest)) {
+      if (!(arg instanceof avs_pb24.NonceRequest)) {
         throw new Error("Expected argument of type aggregator.NonceRequest");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_NonceRequest(buffer_arg) {
-      return avs_pb23.NonceRequest.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.NonceRequest.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_NonceResp(arg) {
-      if (!(arg instanceof avs_pb23.NonceResp)) {
+      if (!(arg instanceof avs_pb24.NonceResp)) {
         throw new Error("Expected argument of type aggregator.NonceResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_NonceResp(buffer_arg) {
-      return avs_pb23.NonceResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.NonceResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunNodeWithInputsReq(arg) {
-      if (!(arg instanceof avs_pb23.RunNodeWithInputsReq)) {
+      if (!(arg instanceof avs_pb24.RunNodeWithInputsReq)) {
         throw new Error("Expected argument of type aggregator.RunNodeWithInputsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_RunNodeWithInputsReq(buffer_arg) {
-      return avs_pb23.RunNodeWithInputsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.RunNodeWithInputsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunNodeWithInputsResp(arg) {
-      if (!(arg instanceof avs_pb23.RunNodeWithInputsResp)) {
+      if (!(arg instanceof avs_pb24.RunNodeWithInputsResp)) {
         throw new Error("Expected argument of type aggregator.RunNodeWithInputsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_RunNodeWithInputsResp(buffer_arg) {
-      return avs_pb23.RunNodeWithInputsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.RunNodeWithInputsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunTriggerReq(arg) {
-      if (!(arg instanceof avs_pb23.RunTriggerReq)) {
+      if (!(arg instanceof avs_pb24.RunTriggerReq)) {
         throw new Error("Expected argument of type aggregator.RunTriggerReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_RunTriggerReq(buffer_arg) {
-      return avs_pb23.RunTriggerReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.RunTriggerReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunTriggerResp(arg) {
-      if (!(arg instanceof avs_pb23.RunTriggerResp)) {
+      if (!(arg instanceof avs_pb24.RunTriggerResp)) {
         throw new Error("Expected argument of type aggregator.RunTriggerResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_RunTriggerResp(buffer_arg) {
-      return avs_pb23.RunTriggerResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.RunTriggerResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_SetWalletReq(arg) {
-      if (!(arg instanceof avs_pb23.SetWalletReq)) {
+      if (!(arg instanceof avs_pb24.SetWalletReq)) {
         throw new Error("Expected argument of type aggregator.SetWalletReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_SetWalletReq(buffer_arg) {
-      return avs_pb23.SetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.SetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_SimulateTaskReq(arg) {
-      if (!(arg instanceof avs_pb23.SimulateTaskReq)) {
+      if (!(arg instanceof avs_pb24.SimulateTaskReq)) {
         throw new Error("Expected argument of type aggregator.SimulateTaskReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_SimulateTaskReq(buffer_arg) {
-      return avs_pb23.SimulateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.SimulateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_Task(arg) {
-      if (!(arg instanceof avs_pb23.Task)) {
+      if (!(arg instanceof avs_pb24.Task)) {
         throw new Error("Expected argument of type aggregator.Task");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_Task(buffer_arg) {
-      return avs_pb23.Task.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.Task.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_TriggerTaskReq(arg) {
-      if (!(arg instanceof avs_pb23.TriggerTaskReq)) {
+      if (!(arg instanceof avs_pb24.TriggerTaskReq)) {
         throw new Error("Expected argument of type aggregator.TriggerTaskReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_TriggerTaskReq(buffer_arg) {
-      return avs_pb23.TriggerTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.TriggerTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_TriggerTaskResp(arg) {
-      if (!(arg instanceof avs_pb23.TriggerTaskResp)) {
+      if (!(arg instanceof avs_pb24.TriggerTaskResp)) {
         throw new Error("Expected argument of type aggregator.TriggerTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_TriggerTaskResp(buffer_arg) {
-      return avs_pb23.TriggerTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.TriggerTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_UpdateSecretResp(arg) {
-      if (!(arg instanceof avs_pb23.UpdateSecretResp)) {
+      if (!(arg instanceof avs_pb24.UpdateSecretResp)) {
         throw new Error("Expected argument of type aggregator.UpdateSecretResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_UpdateSecretResp(buffer_arg) {
-      return avs_pb23.UpdateSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.UpdateSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_WithdrawFundsReq(arg) {
-      if (!(arg instanceof avs_pb23.WithdrawFundsReq)) {
+      if (!(arg instanceof avs_pb24.WithdrawFundsReq)) {
         throw new Error("Expected argument of type aggregator.WithdrawFundsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_WithdrawFundsReq(buffer_arg) {
-      return avs_pb23.WithdrawFundsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.WithdrawFundsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_WithdrawFundsResp(arg) {
-      if (!(arg instanceof avs_pb23.WithdrawFundsResp)) {
+      if (!(arg instanceof avs_pb24.WithdrawFundsResp)) {
         throw new Error("Expected argument of type aggregator.WithdrawFundsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_WithdrawFundsResp(buffer_arg) {
-      return avs_pb23.WithdrawFundsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb24.WithdrawFundsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     var AggregatorService = exports2.AggregatorService = {
       // Exchange for an Auth Key to authenticate in subsequent request
@@ -15716,8 +15710,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetKey",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.GetKeyReq,
-        responseType: avs_pb23.KeyResp,
+        requestType: avs_pb24.GetKeyReq,
+        responseType: avs_pb24.KeyResp,
         requestSerialize: serialize_aggregator_GetKeyReq,
         requestDeserialize: deserialize_aggregator_GetKeyReq,
         responseSerialize: serialize_aggregator_KeyResp,
@@ -15728,8 +15722,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetSignatureFormat",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.GetSignatureFormatReq,
-        responseType: avs_pb23.GetSignatureFormatResp,
+        requestType: avs_pb24.GetSignatureFormatReq,
+        responseType: avs_pb24.GetSignatureFormatResp,
         requestSerialize: serialize_aggregator_GetSignatureFormatReq,
         requestDeserialize: deserialize_aggregator_GetSignatureFormatReq,
         responseSerialize: serialize_aggregator_GetSignatureFormatResp,
@@ -15740,8 +15734,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetNonce",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.NonceRequest,
-        responseType: avs_pb23.NonceResp,
+        requestType: avs_pb24.NonceRequest,
+        responseType: avs_pb24.NonceResp,
         requestSerialize: serialize_aggregator_NonceRequest,
         requestDeserialize: deserialize_aggregator_NonceRequest,
         responseSerialize: serialize_aggregator_NonceResp,
@@ -15751,8 +15745,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetWallet",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.GetWalletReq,
-        responseType: avs_pb23.GetWalletResp,
+        requestType: avs_pb24.GetWalletReq,
+        responseType: avs_pb24.GetWalletResp,
         requestSerialize: serialize_aggregator_GetWalletReq,
         requestDeserialize: deserialize_aggregator_GetWalletReq,
         responseSerialize: serialize_aggregator_GetWalletResp,
@@ -15762,8 +15756,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/SetWallet",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.SetWalletReq,
-        responseType: avs_pb23.GetWalletResp,
+        requestType: avs_pb24.SetWalletReq,
+        responseType: avs_pb24.GetWalletResp,
         requestSerialize: serialize_aggregator_SetWalletReq,
         requestDeserialize: deserialize_aggregator_SetWalletReq,
         responseSerialize: serialize_aggregator_GetWalletResp,
@@ -15773,8 +15767,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListWallets",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.ListWalletReq,
-        responseType: avs_pb23.ListWalletResp,
+        requestType: avs_pb24.ListWalletReq,
+        responseType: avs_pb24.ListWalletResp,
         requestSerialize: serialize_aggregator_ListWalletReq,
         requestDeserialize: deserialize_aggregator_ListWalletReq,
         responseSerialize: serialize_aggregator_ListWalletResp,
@@ -15785,8 +15779,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/WithdrawFunds",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.WithdrawFundsReq,
-        responseType: avs_pb23.WithdrawFundsResp,
+        requestType: avs_pb24.WithdrawFundsReq,
+        responseType: avs_pb24.WithdrawFundsResp,
         requestSerialize: serialize_aggregator_WithdrawFundsReq,
         requestDeserialize: deserialize_aggregator_WithdrawFundsReq,
         responseSerialize: serialize_aggregator_WithdrawFundsResp,
@@ -15797,8 +15791,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CreateTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.CreateTaskReq,
-        responseType: avs_pb23.CreateTaskResp,
+        requestType: avs_pb24.CreateTaskReq,
+        responseType: avs_pb24.CreateTaskResp,
         requestSerialize: serialize_aggregator_CreateTaskReq,
         requestDeserialize: deserialize_aggregator_CreateTaskReq,
         responseSerialize: serialize_aggregator_CreateTaskResp,
@@ -15808,8 +15802,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListTasks",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.ListTasksReq,
-        responseType: avs_pb23.ListTasksResp,
+        requestType: avs_pb24.ListTasksReq,
+        responseType: avs_pb24.ListTasksResp,
         requestSerialize: serialize_aggregator_ListTasksReq,
         requestDeserialize: deserialize_aggregator_ListTasksReq,
         responseSerialize: serialize_aggregator_ListTasksResp,
@@ -15819,8 +15813,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.IdReq,
-        responseType: avs_pb23.Task,
+        requestType: avs_pb24.IdReq,
+        responseType: avs_pb24.Task,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
         responseSerialize: serialize_aggregator_Task,
@@ -15830,8 +15824,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListExecutions",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.ListExecutionsReq,
-        responseType: avs_pb23.ListExecutionsResp,
+        requestType: avs_pb24.ListExecutionsReq,
+        responseType: avs_pb24.ListExecutionsResp,
         requestSerialize: serialize_aggregator_ListExecutionsReq,
         requestDeserialize: deserialize_aggregator_ListExecutionsReq,
         responseSerialize: serialize_aggregator_ListExecutionsResp,
@@ -15841,8 +15835,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecution",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.ExecutionReq,
-        responseType: avs_pb23.Execution,
+        requestType: avs_pb24.ExecutionReq,
+        responseType: avs_pb24.Execution,
         requestSerialize: serialize_aggregator_ExecutionReq,
         requestDeserialize: deserialize_aggregator_ExecutionReq,
         responseSerialize: serialize_aggregator_Execution,
@@ -15852,8 +15846,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecutionStatus",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.ExecutionReq,
-        responseType: avs_pb23.ExecutionStatusResp,
+        requestType: avs_pb24.ExecutionReq,
+        responseType: avs_pb24.ExecutionStatusResp,
         requestSerialize: serialize_aggregator_ExecutionReq,
         requestDeserialize: deserialize_aggregator_ExecutionReq,
         responseSerialize: serialize_aggregator_ExecutionStatusResp,
@@ -15863,8 +15857,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CancelTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.IdReq,
-        responseType: avs_pb23.CancelTaskResp,
+        requestType: avs_pb24.IdReq,
+        responseType: avs_pb24.CancelTaskResp,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
         responseSerialize: serialize_aggregator_CancelTaskResp,
@@ -15874,8 +15868,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/DeleteTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.IdReq,
-        responseType: avs_pb23.DeleteTaskResp,
+        requestType: avs_pb24.IdReq,
+        responseType: avs_pb24.DeleteTaskResp,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
         responseSerialize: serialize_aggregator_DeleteTaskResp,
@@ -15885,8 +15879,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/TriggerTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.TriggerTaskReq,
-        responseType: avs_pb23.TriggerTaskResp,
+        requestType: avs_pb24.TriggerTaskReq,
+        responseType: avs_pb24.TriggerTaskResp,
         requestSerialize: serialize_aggregator_TriggerTaskReq,
         requestDeserialize: deserialize_aggregator_TriggerTaskReq,
         responseSerialize: serialize_aggregator_TriggerTaskResp,
@@ -15899,8 +15893,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CreateSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.CreateOrUpdateSecretReq,
-        responseType: avs_pb23.CreateSecretResp,
+        requestType: avs_pb24.CreateOrUpdateSecretReq,
+        responseType: avs_pb24.CreateSecretResp,
         requestSerialize: serialize_aggregator_CreateOrUpdateSecretReq,
         requestDeserialize: deserialize_aggregator_CreateOrUpdateSecretReq,
         responseSerialize: serialize_aggregator_CreateSecretResp,
@@ -15910,8 +15904,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/DeleteSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.DeleteSecretReq,
-        responseType: avs_pb23.DeleteSecretResp,
+        requestType: avs_pb24.DeleteSecretReq,
+        responseType: avs_pb24.DeleteSecretResp,
         requestSerialize: serialize_aggregator_DeleteSecretReq,
         requestDeserialize: deserialize_aggregator_DeleteSecretReq,
         responseSerialize: serialize_aggregator_DeleteSecretResp,
@@ -15923,8 +15917,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListSecrets",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.ListSecretsReq,
-        responseType: avs_pb23.ListSecretsResp,
+        requestType: avs_pb24.ListSecretsReq,
+        responseType: avs_pb24.ListSecretsResp,
         requestSerialize: serialize_aggregator_ListSecretsReq,
         requestDeserialize: deserialize_aggregator_ListSecretsReq,
         responseSerialize: serialize_aggregator_ListSecretsResp,
@@ -15936,8 +15930,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/UpdateSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.CreateOrUpdateSecretReq,
-        responseType: avs_pb23.UpdateSecretResp,
+        requestType: avs_pb24.CreateOrUpdateSecretReq,
+        responseType: avs_pb24.UpdateSecretResp,
         requestSerialize: serialize_aggregator_CreateOrUpdateSecretReq,
         requestDeserialize: deserialize_aggregator_CreateOrUpdateSecretReq,
         responseSerialize: serialize_aggregator_UpdateSecretResp,
@@ -15953,8 +15947,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetWorkflowCount",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.GetWorkflowCountReq,
-        responseType: avs_pb23.GetWorkflowCountResp,
+        requestType: avs_pb24.GetWorkflowCountReq,
+        responseType: avs_pb24.GetWorkflowCountResp,
         requestSerialize: serialize_aggregator_GetWorkflowCountReq,
         requestDeserialize: deserialize_aggregator_GetWorkflowCountReq,
         responseSerialize: serialize_aggregator_GetWorkflowCountResp,
@@ -15968,8 +15962,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecutionCount",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.GetExecutionCountReq,
-        responseType: avs_pb23.GetExecutionCountResp,
+        requestType: avs_pb24.GetExecutionCountReq,
+        responseType: avs_pb24.GetExecutionCountResp,
         requestSerialize: serialize_aggregator_GetExecutionCountReq,
         requestDeserialize: deserialize_aggregator_GetExecutionCountReq,
         responseSerialize: serialize_aggregator_GetExecutionCountResp,
@@ -15982,8 +15976,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecutionStats",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.GetExecutionStatsReq,
-        responseType: avs_pb23.GetExecutionStatsResp,
+        requestType: avs_pb24.GetExecutionStatsReq,
+        responseType: avs_pb24.GetExecutionStatsResp,
         requestSerialize: serialize_aggregator_GetExecutionStatsReq,
         requestDeserialize: deserialize_aggregator_GetExecutionStatsReq,
         responseSerialize: serialize_aggregator_GetExecutionStatsResp,
@@ -15994,8 +15988,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/RunNodeWithInputs",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.RunNodeWithInputsReq,
-        responseType: avs_pb23.RunNodeWithInputsResp,
+        requestType: avs_pb24.RunNodeWithInputsReq,
+        responseType: avs_pb24.RunNodeWithInputsResp,
         requestSerialize: serialize_aggregator_RunNodeWithInputsReq,
         requestDeserialize: deserialize_aggregator_RunNodeWithInputsReq,
         responseSerialize: serialize_aggregator_RunNodeWithInputsResp,
@@ -16006,8 +16000,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/RunTrigger",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.RunTriggerReq,
-        responseType: avs_pb23.RunTriggerResp,
+        requestType: avs_pb24.RunTriggerReq,
+        responseType: avs_pb24.RunTriggerResp,
         requestSerialize: serialize_aggregator_RunTriggerReq,
         requestDeserialize: deserialize_aggregator_RunTriggerReq,
         responseSerialize: serialize_aggregator_RunTriggerResp,
@@ -16018,8 +16012,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/SimulateTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.SimulateTaskReq,
-        responseType: avs_pb23.Execution,
+        requestType: avs_pb24.SimulateTaskReq,
+        responseType: avs_pb24.Execution,
         requestSerialize: serialize_aggregator_SimulateTaskReq,
         requestDeserialize: deserialize_aggregator_SimulateTaskReq,
         responseSerialize: serialize_aggregator_Execution,
@@ -16030,8 +16024,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetTokenMetadata",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.GetTokenMetadataReq,
-        responseType: avs_pb23.GetTokenMetadataResp,
+        requestType: avs_pb24.GetTokenMetadataReq,
+        responseType: avs_pb24.GetTokenMetadataResp,
         requestSerialize: serialize_aggregator_GetTokenMetadataReq,
         requestDeserialize: deserialize_aggregator_GetTokenMetadataReq,
         responseSerialize: serialize_aggregator_GetTokenMetadataResp,
@@ -16066,7 +16060,7 @@ __export(index_exports, {
   RestAPINode: () => restApi_default,
   Secret: () => secret_default,
   Step: () => step_default,
-  TimeoutPresets: () => import_types21.TimeoutPresets,
+  TimeoutPresets: () => import_types22.TimeoutPresets,
   Trigger: () => Trigger,
   TriggerFactory: () => factory_default,
   Workflow: () => workflow_default,
@@ -16075,7 +16069,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_grpc_js = require("@grpc/grpc-js");
 var import_avs_grpc_pb = __toESM(require_avs_grpc_pb());
-var avs_pb22 = __toESM(require_avs_pb());
+var avs_pb23 = __toESM(require_avs_pb());
 
 // src/models/workflow.ts
 var import_lodash3 = __toESM(require("lodash"));
@@ -17923,6 +17917,10 @@ var Workflow = class _Workflow {
 };
 var workflow_default = Workflow;
 
+// src/models/execution.ts
+var avs_pb21 = __toESM(require_avs_pb());
+var import_types20 = require("@avaprotocol/types");
+
 // src/models/step.ts
 var avs_pb20 = __toESM(require_avs_pb());
 var Step = class _Step {
@@ -18119,13 +18117,29 @@ var Step = class _Step {
 var step_default = Step;
 
 // src/models/execution.ts
+function convertProtobufExecutionStatusToTypes(protobufStatus) {
+  switch (protobufStatus) {
+    case avs_pb21.ExecutionStatus.EXECUTION_STATUS_PENDING:
+      return import_types20.ExecutionStatus.Pending;
+    case avs_pb21.ExecutionStatus.EXECUTION_STATUS_SUCCESS:
+      return import_types20.ExecutionStatus.Success;
+    case avs_pb21.ExecutionStatus.EXECUTION_STATUS_FAILED:
+      return import_types20.ExecutionStatus.Failed;
+    case avs_pb21.ExecutionStatus.EXECUTION_STATUS_PARTIAL_SUCCESS:
+      return import_types20.ExecutionStatus.PartialSuccess;
+    case avs_pb21.ExecutionStatus.EXECUTION_STATUS_UNSPECIFIED:
+    default:
+      return import_types20.ExecutionStatus.Unspecified;
+  }
+}
 var Execution2 = class _Execution {
   constructor(props) {
     this.id = props.id;
     this.startAt = props.startAt;
     this.endAt = props.endAt;
-    this.success = props.success;
+    this.status = props.status;
     this.error = props.error;
+    this.index = props.index;
     this.steps = props.steps.map((s) => new step_default(s));
   }
   /**
@@ -18137,8 +18151,9 @@ var Execution2 = class _Execution {
       id: this.id,
       startAt: this.startAt,
       endAt: this.endAt,
-      success: this.success,
+      status: this.status,
       error: this.error,
+      index: this.index,
       steps: this.steps.map((step) => step.toJson())
     };
   }
@@ -18147,8 +18162,9 @@ var Execution2 = class _Execution {
       id: execution.getId(),
       startAt: execution.getStartAt(),
       endAt: execution.getEndAt(),
-      success: execution.getSuccess(),
+      status: convertProtobufExecutionStatusToTypes(execution.getStatus()),
       error: execution.getError(),
+      index: execution.getIndex(),
       steps: execution.getStepsList().map((step) => step_default.fromResponse(step))
     });
   }
@@ -18157,7 +18173,7 @@ var Execution2 = class _Execution {
 var execution_default = Execution2;
 
 // src/models/secret.ts
-var avs_pb21 = __toESM(require_avs_pb());
+var avs_pb22 = __toESM(require_avs_pb());
 var Secret = class {
   constructor(props) {
     this.name = props.name;
@@ -18170,7 +18186,7 @@ var Secret = class {
     this.description = props.description;
   }
   toRequest() {
-    const request = new avs_pb21.CreateOrUpdateSecretReq();
+    const request = new avs_pb22.CreateOrUpdateSecretReq();
     request.setName(this.name);
     if (this.secret) {
       request.setSecret(this.secret);
@@ -18187,21 +18203,23 @@ var Secret = class {
 var secret_default = Secret;
 
 // src/index.ts
-var import_types20 = require("@avaprotocol/types");
+var import_types21 = require("@avaprotocol/types");
 var import_avs_pb = __toESM(require_avs_pb());
 var google_protobuf_struct_pb4 = __toESM(require("google-protobuf/google/protobuf/struct_pb"));
-var import_types21 = require("@avaprotocol/types");
+var import_types22 = require("@avaprotocol/types");
 function convertProtobufExecutionStatus(protobufStatus) {
   switch (protobufStatus) {
     case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_PENDING:
-      return import_types20.ExecutionStatus.Pending;
-    case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_COMPLETED:
-      return import_types20.ExecutionStatus.Completed;
+      return import_types21.ExecutionStatus.Pending;
+    case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_SUCCESS:
+      return import_types21.ExecutionStatus.Success;
     case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_FAILED:
-      return import_types20.ExecutionStatus.Failed;
+      return import_types21.ExecutionStatus.Failed;
+    case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_PARTIAL_SUCCESS:
+      return import_types21.ExecutionStatus.PartialSuccess;
     case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_UNSPECIFIED:
     default:
-      return import_types20.ExecutionStatus.Unspecified;
+      return import_types21.ExecutionStatus.Unspecified;
   }
 }
 var BaseClient = class {
@@ -18244,7 +18262,7 @@ var BaseClient = class {
   sendFastRequest(method, request, options) {
     return this.sendGrpcRequest(method, request, {
       ...options,
-      timeout: import_types20.TimeoutPresets.FAST
+      timeout: import_types21.TimeoutPresets.FAST
     });
   }
   /**
@@ -18257,7 +18275,7 @@ var BaseClient = class {
   sendSlowRequest(method, request, options) {
     return this.sendGrpcRequest(method, request, {
       ...options,
-      timeout: import_types20.TimeoutPresets.SLOW
+      timeout: import_types21.TimeoutPresets.SLOW
     });
   }
   /**
@@ -18270,7 +18288,7 @@ var BaseClient = class {
   sendNoRetryRequest(method, request, options) {
     return this.sendGrpcRequest(method, request, {
       ...options,
-      timeout: import_types20.TimeoutPresets.NO_RETRY
+      timeout: import_types21.TimeoutPresets.NO_RETRY
     });
   }
   /**
@@ -18295,7 +18313,7 @@ var BaseClient = class {
    * @returns {Promise<GetSignatureFormatResponse>} - The response containing the signature format
    */
   async getSignatureFormat(wallet) {
-    const request = new avs_pb22.GetSignatureFormatReq();
+    const request = new avs_pb23.GetSignatureFormatReq();
     request.setWallet(wallet);
     const result = await this.sendGrpcRequest("getSignatureFormat", request);
     return { message: result.getMessage() };
@@ -18310,7 +18328,7 @@ var BaseClient = class {
     message,
     apiKey
   }) {
-    const request = new avs_pb22.GetKeyReq();
+    const request = new avs_pb23.GetKeyReq();
     request.setMessage(message);
     request.setSignature(apiKey);
     const result = await this.sendGrpcRequest("getKey", request);
@@ -18326,7 +18344,7 @@ var BaseClient = class {
     message,
     signature
   }) {
-    const request = new avs_pb22.GetKeyReq();
+    const request = new avs_pb23.GetKeyReq();
     request.setMessage(message);
     request.setSignature(signature);
     const result = await this.sendGrpcRequest(
@@ -18402,7 +18420,7 @@ var BaseClient = class {
             const metadata = new import_grpc_js.Metadata();
             const authKey = options?.authKey || this.authKey;
             if (authKey) {
-              metadata.set(import_types20.AUTH_KEY_HEADER, authKey);
+              metadata.set(import_types21.AUTH_KEY_HEADER, authKey);
             }
             const call = this.rpcClient[method](
               request,
@@ -18462,7 +18480,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<SmartWallet[]>} - The list of SmartWallet objects
    */
   async getWallets(options) {
-    const request = new avs_pb22.ListWalletReq();
+    const request = new avs_pb23.ListWalletReq();
     const result = await this.sendGrpcRequest("listWallets", request, options);
     return result.getItemsList().map((item) => item.toObject());
   }
@@ -18474,7 +18492,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<SmartWallet>} - The added SmartWallet object
    */
   async getWallet({ salt, factoryAddress }, options) {
-    const request = new avs_pb22.GetWalletReq();
+    const request = new avs_pb23.GetWalletReq();
     request.setSalt(salt);
     if (factoryAddress) {
       request.setFactoryAddress(factoryAddress);
@@ -18503,7 +18521,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<SmartWallet>} - The updated SmartWallet object
    */
   async setWallet({ salt, factoryAddress }, { isHidden }, requestOptions) {
-    const request = new avs_pb22.SetWalletReq();
+    const request = new avs_pb23.SetWalletReq();
     request.setSalt(salt);
     if (factoryAddress) {
       request.setFactoryAddress(factoryAddress);
@@ -18540,7 +18558,7 @@ var Client = class extends BaseClient {
     token,
     smartWalletAddress
   }, options) {
-    const request = new avs_pb22.WithdrawFundsReq();
+    const request = new avs_pb23.WithdrawFundsReq();
     request.setRecipientAddress(recipientAddress);
     request.setAmount(amount);
     request.setToken(token);
@@ -18586,7 +18604,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ items: WorkflowProps[]; pageInfo: PageInfo }>} - The list of WorkflowProps objects with nested pagination metadata
    */
   async getWorkflows(addresses, options) {
-    const request = new avs_pb22.ListTasksReq();
+    const request = new avs_pb23.ListTasksReq();
     for (const a of addresses) {
       request.addSmartWalletAddress(a);
     }
@@ -18596,7 +18614,7 @@ var Client = class extends BaseClient {
     if (options?.after) {
       request.setAfter(options.after);
     }
-    request.setLimit(options?.limit || import_types20.DEFAULT_LIMIT);
+    request.setLimit(options?.limit || import_types21.DEFAULT_LIMIT);
     if (options?.includeNodes) {
       request.setIncludeNodes(options.includeNodes);
     }
@@ -18625,7 +18643,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<number>} - The count of workflows
    */
   async getWorkflowCount(addresses, options) {
-    const request = new avs_pb22.GetWorkflowCountReq();
+    const request = new avs_pb23.GetWorkflowCountReq();
     request.setAddressesList(addresses);
     const result = await this.sendGrpcRequest("getWorkflowCount", request, options);
     return result.getTotal();
@@ -18641,7 +18659,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ items: ExecutionProps[]; pageInfo: PageInfo }>} - The list of ExecutionProps objects with nested pagination metadata
    */
   async getExecutions(workflows, options) {
-    const request = new avs_pb22.ListExecutionsReq();
+    const request = new avs_pb23.ListExecutionsReq();
     for (const w of workflows) {
       request.addTaskIds(w);
     }
@@ -18651,7 +18669,7 @@ var Client = class extends BaseClient {
     if (options?.after) {
       request.setAfter(options.after);
     }
-    request.setLimit(options?.limit || import_types20.DEFAULT_LIMIT);
+    request.setLimit(options?.limit || import_types21.DEFAULT_LIMIT);
     const result = await this.sendGrpcRequest("listExecutions", request, options);
     const pageInfo = result.getPageInfo();
     if (!pageInfo) {
@@ -18675,7 +18693,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<ExecutionProps>} - The ExecutionProps object
    */
   async getExecution(workflowId, executionId, options) {
-    const request = new avs_pb22.ExecutionReq();
+    const request = new avs_pb23.ExecutionReq();
     request.setTaskId(workflowId);
     request.setExecutionId(executionId);
     const result = await this.sendGrpcRequest("getExecution", request, options);
@@ -18688,7 +18706,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<number>} - The count of executions
    */
   async getExecutionCount(workflows, options) {
-    const request = new avs_pb22.GetExecutionCountReq();
+    const request = new avs_pb23.GetExecutionCountReq();
     request.setWorkflowIdsList(workflows);
     const result = await this.sendGrpcRequest("getExecutionCount", request, options);
     return result.getTotal();
@@ -18702,7 +18720,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<GetExecutionStatsResponse>} - Execution statistics
    */
   async getExecutionStats(options) {
-    const request = new avs_pb22.GetExecutionStatsReq();
+    const request = new avs_pb23.GetExecutionStatsReq();
     if (options?.workflowIds && options.workflowIds.length > 0) {
       request.setWorkflowIdsList(options.workflowIds);
     }
@@ -18725,7 +18743,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<ExecutionStatus>} - The status of the execution
    */
   async getExecutionStatus(workflowId, executionId, options) {
-    const request = new avs_pb22.ExecutionReq();
+    const request = new avs_pb23.ExecutionReq();
     request.setTaskId(workflowId);
     request.setExecutionId(executionId);
     const result = await this.sendGrpcRequest("getExecutionStatus", request, options);
@@ -18738,7 +18756,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<Workflow>} - The Workflow object
    */
   async getWorkflow(id, options) {
-    const request = new avs_pb22.IdReq();
+    const request = new avs_pb23.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "getTask",
@@ -18761,14 +18779,14 @@ var Client = class extends BaseClient {
     triggerData,
     isBlocking = false
   }, options) {
-    const request = new avs_pb22.TriggerTaskReq();
+    const request = new avs_pb23.TriggerTaskReq();
     request.setTaskId(id);
-    request.setTriggerType(import_types20.TriggerTypeConverter.toProtobuf(triggerData.type));
+    request.setTriggerType(import_types21.TriggerTypeConverter.toProtobuf(triggerData.type));
     request.setIsBlocking(isBlocking);
     switch (triggerData.type) {
-      case import_types20.TriggerType.FixedTime: {
+      case import_types21.TriggerType.FixedTime: {
         const fixedTimeData = triggerData;
-        const fixedTimeOutput = new avs_pb22.FixedTimeTrigger.Output();
+        const fixedTimeOutput = new avs_pb23.FixedTimeTrigger.Output();
         const triggerOutputData = {
           timestamp: fixedTimeData.timestamp,
           timestampIso: fixedTimeData.timestampIso
@@ -18781,9 +18799,9 @@ var Client = class extends BaseClient {
         request.setFixedTimeTrigger(fixedTimeOutput);
         break;
       }
-      case import_types20.TriggerType.Cron: {
+      case import_types21.TriggerType.Cron: {
         const cronData = triggerData;
-        const cronOutput = new avs_pb22.CronTrigger.Output();
+        const cronOutput = new avs_pb23.CronTrigger.Output();
         const triggerOutputData = {
           timestamp: cronData.timestamp,
           timestampIso: cronData.timestampIso
@@ -18796,9 +18814,9 @@ var Client = class extends BaseClient {
         request.setCronTrigger(cronOutput);
         break;
       }
-      case import_types20.TriggerType.Block: {
+      case import_types21.TriggerType.Block: {
         const blockData = triggerData;
-        const blockOutput = new avs_pb22.BlockTrigger.Output();
+        const blockOutput = new avs_pb23.BlockTrigger.Output();
         const triggerOutputData = {
           blockNumber: blockData.blockNumber,
           blockHash: blockData.blockHash || "",
@@ -18816,9 +18834,9 @@ var Client = class extends BaseClient {
         request.setBlockTrigger(blockOutput);
         break;
       }
-      case import_types20.TriggerType.Event: {
+      case import_types21.TriggerType.Event: {
         const eventData = triggerData;
-        const eventOutput = new avs_pb22.EventTrigger.Output();
+        const eventOutput = new avs_pb23.EventTrigger.Output();
         if (eventData.data) {
           const protobufValue = convertJSValueToProtobuf(eventData.data);
           eventOutput.setData(protobufValue);
@@ -18826,9 +18844,9 @@ var Client = class extends BaseClient {
         request.setEventTrigger(eventOutput);
         break;
       }
-      case import_types20.TriggerType.Manual: {
+      case import_types21.TriggerType.Manual: {
         const manualData = triggerData;
-        const manualOutput = new avs_pb22.ManualTrigger.Output();
+        const manualOutput = new avs_pb23.ManualTrigger.Output();
         if (manualData.data) {
           const protobufValue = convertJSValueToProtobuf(manualData.data);
           manualOutput.setData(protobufValue);
@@ -18836,7 +18854,7 @@ var Client = class extends BaseClient {
         request.setManualTrigger(manualOutput);
         break;
       }
-      case import_types20.TriggerType.Unspecified:
+      case import_types21.TriggerType.Unspecified:
         break;
       default:
         throw new Error(
@@ -18856,9 +18874,6 @@ var Client = class extends BaseClient {
     if (responseObject.endAt !== void 0) {
       response.endAt = responseObject.endAt;
     }
-    if (responseObject.success !== void 0) {
-      response.success = responseObject.success;
-    }
     if (responseObject.error) {
       response.error = responseObject.error;
     }
@@ -18903,7 +18918,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<CancelTaskResponse>} - The response from canceling the workflow
    */
   async cancelWorkflow(id, options) {
-    const request = new avs_pb22.IdReq();
+    const request = new avs_pb23.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest("cancelTask", request, options);
     return {
@@ -18922,7 +18937,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<DeleteTaskResponse>} - The response from deleting the workflow
    */
   async deleteWorkflow(id, options) {
-    const request = new avs_pb22.IdReq();
+    const request = new avs_pb23.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest("deleteTask", request, options);
     return {
@@ -18945,7 +18960,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<CreateSecretResponse>} - Structured response with creation details
    */
   async createSecret(name, value, options) {
-    const request = new avs_pb22.CreateOrUpdateSecretReq();
+    const request = new avs_pb23.CreateOrUpdateSecretReq();
     request.setName(name);
     request.setSecret(value);
     if (options?.workflowId) {
@@ -18975,7 +18990,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<UpdateSecretResponse>} - Structured response with update details
    */
   async updateSecret(name, value, options) {
-    const request = new avs_pb22.CreateOrUpdateSecretReq();
+    const request = new avs_pb23.CreateOrUpdateSecretReq();
     request.setName(name);
     request.setSecret(value);
     if (options?.workflowId) {
@@ -19009,7 +19024,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ items: SecretProps[]; pageInfo: PageInfo }>} - The list of Secret objects with nested pagination metadata
    */
   async getSecrets(options) {
-    const request = new avs_pb22.ListSecretsReq();
+    const request = new avs_pb23.ListSecretsReq();
     if (options?.workflowId) {
       request.setWorkflowId(options.workflowId);
     }
@@ -19019,7 +19034,7 @@ var Client = class extends BaseClient {
     if (options?.after) {
       request.setAfter(options.after);
     }
-    request.setLimit(options?.limit || import_types20.DEFAULT_LIMIT);
+    request.setLimit(options?.limit || import_types21.DEFAULT_LIMIT);
     if (options?.includeTimestamps) {
       request.setIncludeTimestamps(options.includeTimestamps);
     }
@@ -19064,7 +19079,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<DeleteSecretResponse>} - Structured response with deletion details
    */
   async deleteSecret(name, options) {
-    const request = new avs_pb22.DeleteSecretReq();
+    const request = new avs_pb23.DeleteSecretReq();
     request.setName(name);
     if (options?.workflowId) {
       request.setWorkflowId(options.workflowId);
@@ -19093,11 +19108,11 @@ var Client = class extends BaseClient {
    */
   async runNodeWithInputs({ nodeType, nodeConfig, inputVariables = {} }, options) {
     const triggerTypes = [
-      import_types20.TriggerType.Block,
-      import_types20.TriggerType.FixedTime,
-      import_types20.TriggerType.Cron,
-      import_types20.TriggerType.Event,
-      import_types20.TriggerType.Manual
+      import_types21.TriggerType.Block,
+      import_types21.TriggerType.FixedTime,
+      import_types21.TriggerType.Cron,
+      import_types21.TriggerType.Event,
+      import_types21.TriggerType.Manual
     ];
     if (triggerTypes.includes(nodeType)) {
       return {
@@ -19106,8 +19121,8 @@ var Client = class extends BaseClient {
         data: null
       };
     }
-    const request = new avs_pb22.RunNodeWithInputsReq();
-    const protobufNodeType = import_types20.NodeTypeGoConverter.fromGoString(nodeType);
+    const request = new avs_pb23.RunNodeWithInputsReq();
+    const protobufNodeType = import_types21.NodeTypeGoConverter.fromGoString(nodeType);
     request.setNodeType(protobufNodeType);
     const nodeConfigMap = request.getNodeConfigMap();
     for (const [key, value] of Object.entries(nodeConfig)) {
@@ -19137,8 +19152,8 @@ var Client = class extends BaseClient {
    * @returns {Promise<RunTriggerResponse>} - The response from running the trigger
    */
   async runTrigger({ triggerType, triggerConfig }, options) {
-    const request = new avs_pb22.RunTriggerReq();
-    const protobufTriggerType = import_types20.TriggerTypeGoConverter.fromGoString(triggerType);
+    const request = new avs_pb23.RunTriggerReq();
+    const protobufTriggerType = import_types21.TriggerTypeGoConverter.fromGoString(triggerType);
     request.setTriggerType(protobufTriggerType);
     const triggerConfigMap = request.getTriggerConfigMap();
     for (const [key, value] of Object.entries(triggerConfig)) {
@@ -19174,7 +19189,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<ExecutionProps>} - The response from simulating the task
    */
   async simulateWorkflow({ trigger, nodes, edges, inputVariables = {} }, options) {
-    const request = new avs_pb22.SimulateTaskReq();
+    const request = new avs_pb23.SimulateTaskReq();
     const triggerSdk = factory_default.create(trigger);
     request.setTrigger(triggerSdk.toRequest());
     const nodeMessages = nodes.map((node) => {
@@ -19203,7 +19218,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<GetTokenMetadataResponse>} - The response containing token metadata
    */
   async getTokenMetadata({ address }, options) {
-    const request = new avs_pb22.GetTokenMetadataReq();
+    const request = new avs_pb23.GetTokenMetadataReq();
     request.setAddress(address);
     const result = await this.sendGrpcRequest("getTokenMetadata", request, options);
     const token = result.getToken();