@avaprotocol/sdk-js 1.6.6 → 1.6.7

package/dist/index.js

@@ -137,6 +137,9 @@ var require_avs_pb = __commonJS({
     goog.exportSymbol("proto.aggregator.LoopNode.Config", null, global);
     goog.exportSymbol("proto.aggregator.LoopNode.Output", null, global);
     goog.exportSymbol("proto.aggregator.LoopNode.RunnerCase", null, global);
+    goog.exportSymbol("proto.aggregator.ManualTrigger", null, global);
+    goog.exportSymbol("proto.aggregator.ManualTrigger.Config", null, global);
+    goog.exportSymbol("proto.aggregator.ManualTrigger.Output", null, global);
     goog.exportSymbol("proto.aggregator.NodeType", null, global);
     goog.exportSymbol("proto.aggregator.NonceRequest", null, global);
     goog.exportSymbol("proto.aggregator.NonceResp", null, global);
@@ -269,6 +272,27 @@ var require_avs_pb = __commonJS({
     if (goog.DEBUG && !COMPILED) {
       proto.aggregator.EventTrigger.TransferLogOutput.displayName = "proto.aggregator.EventTrigger.TransferLogOutput";
     }
+    proto.aggregator.ManualTrigger = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.ManualTrigger, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.ManualTrigger.displayName = "proto.aggregator.ManualTrigger";
+    }
+    proto.aggregator.ManualTrigger.Config = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.ManualTrigger.Config, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.ManualTrigger.Config.displayName = "proto.aggregator.ManualTrigger.Config";
+    }
+    proto.aggregator.ManualTrigger.Output = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.ManualTrigger.Output, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.ManualTrigger.Output.displayName = "proto.aggregator.ManualTrigger.Output";
+    }
     proto.aggregator.TaskTrigger = function(opt_data) {
       jspb.Message.initialize(this, opt_data, 0, -1, null, proto.aggregator.TaskTrigger.oneofGroups_);
     };
@@ -2359,6 +2383,178 @@ var require_avs_pb = __commonJS({
     proto.aggregator.EventTrigger.prototype.hasConfig = function() {
       return jspb.Message.getField(this, 1) != null;
     };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.ManualTrigger.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.ManualTrigger.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.ManualTrigger.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          config: (f = msg.getConfig()) && proto.aggregator.ManualTrigger.Config.toObject(includeInstance, f)
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.ManualTrigger.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.ManualTrigger();
+      return proto.aggregator.ManualTrigger.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.ManualTrigger.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = new proto.aggregator.ManualTrigger.Config();
+            reader.readMessage(value, proto.aggregator.ManualTrigger.Config.deserializeBinaryFromReader);
+            msg.setConfig(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.ManualTrigger.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.ManualTrigger.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.ManualTrigger.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getConfig();
+      if (f != null) {
+        writer.writeMessage(
+          1,
+          f,
+          proto.aggregator.ManualTrigger.Config.serializeBinaryToWriter
+        );
+      }
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.ManualTrigger.Config.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.ManualTrigger.Config.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.ManualTrigger.Config.toObject = function(includeInstance, msg) {
+        var f, obj = {};
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.ManualTrigger.Config.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.ManualTrigger.Config();
+      return proto.aggregator.ManualTrigger.Config.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.ManualTrigger.Config.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.ManualTrigger.Config.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.ManualTrigger.Config.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.ManualTrigger.Config.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.ManualTrigger.Output.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.ManualTrigger.Output.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.ManualTrigger.Output.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          runAt: jspb.Message.getFieldWithDefault(msg, 1, 0)
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.ManualTrigger.Output.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.ManualTrigger.Output();
+      return proto.aggregator.ManualTrigger.Output.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.ManualTrigger.Output.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = (
+              /** @type {number} */
+              reader.readUint64()
+            );
+            msg.setRunAt(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.ManualTrigger.Output.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.ManualTrigger.Output.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.ManualTrigger.Output.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getRunAt();
+      if (f !== 0) {
+        writer.writeUint64(
+          1,
+          f
+        );
+      }
+    };
+    proto.aggregator.ManualTrigger.Output.prototype.getRunAt = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 1, 0)
+      );
+    };
+    proto.aggregator.ManualTrigger.Output.prototype.setRunAt = function(value) {
+      return jspb.Message.setProto3IntField(this, 1, value);
+    };
+    proto.aggregator.ManualTrigger.prototype.getConfig = function() {
+      return (
+        /** @type{?proto.aggregator.ManualTrigger.Config} */
+        jspb.Message.getWrapperField(this, proto.aggregator.ManualTrigger.Config, 1)
+      );
+    };
+    proto.aggregator.ManualTrigger.prototype.setConfig = function(value) {
+      return jspb.Message.setWrapperField(this, 1, value);
+    };
+    proto.aggregator.ManualTrigger.prototype.clearConfig = function() {
+      return this.setConfig(void 0);
+    };
+    proto.aggregator.ManualTrigger.prototype.hasConfig = function() {
+      return jspb.Message.getField(this, 1) != null;
+    };
     proto.aggregator.TaskTrigger.oneofGroups_ = [[2, 3, 4, 5, 6]];
     proto.aggregator.TaskTrigger.TriggerTypeCase = {
       TRIGGER_TYPE_NOT_SET: 0,
@@ -3838,7 +4034,7 @@ var require_avs_pb = __commonJS({
       };
       proto.aggregator.RestAPINode.Output.toObject = function(includeInstance, msg) {
         var f, obj = {
-          data: (f = msg.getData()) && google_protobuf_any_pb.Any.toObject(includeInstance, f)
+          data: (f = msg.getData()) && google_protobuf_struct_pb.Value.toObject(includeInstance, f)
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -3859,8 +4055,8 @@ var require_avs_pb = __commonJS({
         var field = reader.getFieldNumber();
         switch (field) {
           case 1:
-            var value = new google_protobuf_any_pb.Any();
-            reader.readMessage(value, google_protobuf_any_pb.Any.deserializeBinaryFromReader);
+            var value = new google_protobuf_struct_pb.Value();
+            reader.readMessage(value, google_protobuf_struct_pb.Value.deserializeBinaryFromReader);
             msg.setData(value);
             break;
           default:
@@ -3882,14 +4078,14 @@ var require_avs_pb = __commonJS({
         writer.writeMessage(
           1,
           f,
-          google_protobuf_any_pb.Any.serializeBinaryToWriter
+          google_protobuf_struct_pb.Value.serializeBinaryToWriter
         );
       }
     };
     proto.aggregator.RestAPINode.Output.prototype.getData = function() {
       return (
-        /** @type{?proto.google.protobuf.Any} */
-        jspb.Message.getWrapperField(this, google_protobuf_any_pb.Any, 1)
+        /** @type{?proto.google.protobuf.Value} */
+        jspb.Message.getWrapperField(this, google_protobuf_struct_pb.Value, 1)
       );
     };
     proto.aggregator.RestAPINode.Output.prototype.setData = function(value) {
@@ -11463,13 +11659,14 @@ var require_avs_pb = __commonJS({
       this.getTriggerConfigMap().clear();
       return this;
     };
-    proto.aggregator.RunTriggerResp.oneofGroups_ = [[10, 11, 12, 13]];
+    proto.aggregator.RunTriggerResp.oneofGroups_ = [[10, 11, 12, 13, 14]];
     proto.aggregator.RunTriggerResp.OutputDataCase = {
       OUTPUT_DATA_NOT_SET: 0,
       BLOCK_TRIGGER: 10,
       FIXED_TIME_TRIGGER: 11,
       CRON_TRIGGER: 12,
-      EVENT_TRIGGER: 13
+      EVENT_TRIGGER: 13,
+      MANUAL_TRIGGER: 14
     };
     proto.aggregator.RunTriggerResp.prototype.getOutputDataCase = function() {
       return (
@@ -11489,7 +11686,8 @@ var require_avs_pb = __commonJS({
           blockTrigger: (f = msg.getBlockTrigger()) && proto.aggregator.BlockTrigger.Output.toObject(includeInstance, f),
           fixedTimeTrigger: (f = msg.getFixedTimeTrigger()) && proto.aggregator.FixedTimeTrigger.Output.toObject(includeInstance, f),
           cronTrigger: (f = msg.getCronTrigger()) && proto.aggregator.CronTrigger.Output.toObject(includeInstance, f),
-          eventTrigger: (f = msg.getEventTrigger()) && proto.aggregator.EventTrigger.Output.toObject(includeInstance, f)
+          eventTrigger: (f = msg.getEventTrigger()) && proto.aggregator.EventTrigger.Output.toObject(includeInstance, f),
+          manualTrigger: (f = msg.getManualTrigger()) && proto.aggregator.ManualTrigger.Output.toObject(includeInstance, f)
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -11550,6 +11748,11 @@ var require_avs_pb = __commonJS({
             reader.readMessage(value, proto.aggregator.EventTrigger.Output.deserializeBinaryFromReader);
             msg.setEventTrigger(value);
             break;
+          case 14:
+            var value = new proto.aggregator.ManualTrigger.Output();
+            reader.readMessage(value, proto.aggregator.ManualTrigger.Output.deserializeBinaryFromReader);
+            msg.setManualTrigger(value);
+            break;
           default:
             reader.skipField();
             break;
@@ -11617,6 +11820,14 @@ var require_avs_pb = __commonJS({
           proto.aggregator.EventTrigger.Output.serializeBinaryToWriter
         );
       }
+      f = message.getManualTrigger();
+      if (f != null) {
+        writer.writeMessage(
+          14,
+          f,
+          proto.aggregator.ManualTrigger.Output.serializeBinaryToWriter
+        );
+      }
     };
     proto.aggregator.RunTriggerResp.prototype.getSuccess = function() {
       return (
@@ -11705,6 +11916,21 @@ var require_avs_pb = __commonJS({
     proto.aggregator.RunTriggerResp.prototype.hasEventTrigger = function() {
       return jspb.Message.getField(this, 13) != null;
     };
+    proto.aggregator.RunTriggerResp.prototype.getManualTrigger = function() {
+      return (
+        /** @type{?proto.aggregator.ManualTrigger.Output} */
+        jspb.Message.getWrapperField(this, proto.aggregator.ManualTrigger.Output, 14)
+      );
+    };
+    proto.aggregator.RunTriggerResp.prototype.setManualTrigger = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 14, proto.aggregator.RunTriggerResp.oneofGroups_[0], value);
+    };
+    proto.aggregator.RunTriggerResp.prototype.clearManualTrigger = function() {
+      return this.setManualTrigger(void 0);
+    };
+    proto.aggregator.RunTriggerResp.prototype.hasManualTrigger = function() {
+      return jspb.Message.getField(this, 14) != null;
+    };
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.Evm.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.Evm.toObject(opt_includeInstance, this);
@@ -12844,352 +13070,352 @@ 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_pb25 = 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");
     var google_protobuf_any_pb = require("google-protobuf/google/protobuf/any_pb.js");
     var google_protobuf_struct_pb = require("google-protobuf/google/protobuf/struct_pb.js");
     function serialize_aggregator_CreateOrUpdateSecretReq(arg) {
-      if (!(arg instanceof avs_pb23.CreateOrUpdateSecretReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.CreateOrUpdateSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateTaskReq(arg) {
-      if (!(arg instanceof avs_pb23.CreateTaskReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateTaskResp(arg) {
-      if (!(arg instanceof avs_pb23.CreateTaskResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_DeleteSecretReq(arg) {
-      if (!(arg instanceof avs_pb23.DeleteSecretReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.DeleteSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_Execution(arg) {
-      if (!(arg instanceof avs_pb23.Execution)) {
+      if (!(arg instanceof avs_pb25.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_pb25.Execution.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ExecutionReq(arg) {
-      if (!(arg instanceof avs_pb23.ExecutionReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.ExecutionReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ExecutionStatusResp(arg) {
-      if (!(arg instanceof avs_pb23.ExecutionStatusResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.ExecutionStatusResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionCountReq(arg) {
-      if (!(arg instanceof avs_pb23.GetExecutionCountReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetExecutionCountReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionCountResp(arg) {
-      if (!(arg instanceof avs_pb23.GetExecutionCountResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetExecutionCountResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionStatsReq(arg) {
-      if (!(arg instanceof avs_pb23.GetExecutionStatsReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetExecutionStatsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionStatsResp(arg) {
-      if (!(arg instanceof avs_pb23.GetExecutionStatsResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetExecutionStatsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetKeyReq(arg) {
-      if (!(arg instanceof avs_pb23.GetKeyReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetKeyReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetSignatureFormatReq(arg) {
-      if (!(arg instanceof avs_pb23.GetSignatureFormatReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetSignatureFormatReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetSignatureFormatResp(arg) {
-      if (!(arg instanceof avs_pb23.GetSignatureFormatResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetSignatureFormatResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWalletReq(arg) {
-      if (!(arg instanceof avs_pb23.GetWalletReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWalletResp(arg) {
-      if (!(arg instanceof avs_pb23.GetWalletResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWorkflowCountReq(arg) {
-      if (!(arg instanceof avs_pb23.GetWorkflowCountReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetWorkflowCountReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWorkflowCountResp(arg) {
-      if (!(arg instanceof avs_pb23.GetWorkflowCountResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.GetWorkflowCountResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_IdReq(arg) {
-      if (!(arg instanceof avs_pb23.IdReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.IdReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_KeyResp(arg) {
-      if (!(arg instanceof avs_pb23.KeyResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.KeyResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListExecutionsReq(arg) {
-      if (!(arg instanceof avs_pb23.ListExecutionsReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.ListExecutionsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListExecutionsResp(arg) {
-      if (!(arg instanceof avs_pb23.ListExecutionsResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.ListExecutionsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListSecretsReq(arg) {
-      if (!(arg instanceof avs_pb23.ListSecretsReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.ListSecretsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListSecretsResp(arg) {
-      if (!(arg instanceof avs_pb23.ListSecretsResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.ListSecretsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListTasksReq(arg) {
-      if (!(arg instanceof avs_pb23.ListTasksReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.ListTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListTasksResp(arg) {
-      if (!(arg instanceof avs_pb23.ListTasksResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.ListTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListWalletReq(arg) {
-      if (!(arg instanceof avs_pb23.ListWalletReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.ListWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListWalletResp(arg) {
-      if (!(arg instanceof avs_pb23.ListWalletResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.ListWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_NonceRequest(arg) {
-      if (!(arg instanceof avs_pb23.NonceRequest)) {
+      if (!(arg instanceof avs_pb25.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_pb25.NonceRequest.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_NonceResp(arg) {
-      if (!(arg instanceof avs_pb23.NonceResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.NonceResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunNodeWithInputsReq(arg) {
-      if (!(arg instanceof avs_pb23.RunNodeWithInputsReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.RunNodeWithInputsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunNodeWithInputsResp(arg) {
-      if (!(arg instanceof avs_pb23.RunNodeWithInputsResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.RunNodeWithInputsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunTriggerReq(arg) {
-      if (!(arg instanceof avs_pb23.RunTriggerReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.RunTriggerReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunTriggerResp(arg) {
-      if (!(arg instanceof avs_pb23.RunTriggerResp)) {
+      if (!(arg instanceof avs_pb25.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_pb25.RunTriggerResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_SetWalletReq(arg) {
-      if (!(arg instanceof avs_pb23.SetWalletReq)) {
+      if (!(arg instanceof avs_pb25.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_pb25.SetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_Task(arg) {
-      if (!(arg instanceof avs_pb23.Task)) {
+      if (!(arg instanceof avs_pb25.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_pb25.Task.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_UserTriggerTaskReq(arg) {
-      if (!(arg instanceof avs_pb23.UserTriggerTaskReq)) {
+      if (!(arg instanceof avs_pb25.UserTriggerTaskReq)) {
         throw new Error("Expected argument of type aggregator.UserTriggerTaskReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_UserTriggerTaskReq(buffer_arg) {
-      return avs_pb23.UserTriggerTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.UserTriggerTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_UserTriggerTaskResp(arg) {
-      if (!(arg instanceof avs_pb23.UserTriggerTaskResp)) {
+      if (!(arg instanceof avs_pb25.UserTriggerTaskResp)) {
         throw new Error("Expected argument of type aggregator.UserTriggerTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_UserTriggerTaskResp(buffer_arg) {
-      return avs_pb23.UserTriggerTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.UserTriggerTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_google_protobuf_BoolValue(arg) {
       if (!(arg instanceof google_protobuf_wrappers_pb.BoolValue)) {
@@ -13206,8 +13432,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_pb25.GetKeyReq,
+        responseType: avs_pb25.KeyResp,
         requestSerialize: serialize_aggregator_GetKeyReq,
         requestDeserialize: deserialize_aggregator_GetKeyReq,
         responseSerialize: serialize_aggregator_KeyResp,
@@ -13218,8 +13444,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_pb25.GetSignatureFormatReq,
+        responseType: avs_pb25.GetSignatureFormatResp,
         requestSerialize: serialize_aggregator_GetSignatureFormatReq,
         requestDeserialize: deserialize_aggregator_GetSignatureFormatReq,
         responseSerialize: serialize_aggregator_GetSignatureFormatResp,
@@ -13230,8 +13456,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_pb25.NonceRequest,
+        responseType: avs_pb25.NonceResp,
         requestSerialize: serialize_aggregator_NonceRequest,
         requestDeserialize: deserialize_aggregator_NonceRequest,
         responseSerialize: serialize_aggregator_NonceResp,
@@ -13241,8 +13467,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_pb25.GetWalletReq,
+        responseType: avs_pb25.GetWalletResp,
         requestSerialize: serialize_aggregator_GetWalletReq,
         requestDeserialize: deserialize_aggregator_GetWalletReq,
         responseSerialize: serialize_aggregator_GetWalletResp,
@@ -13252,8 +13478,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_pb25.SetWalletReq,
+        responseType: avs_pb25.GetWalletResp,
         requestSerialize: serialize_aggregator_SetWalletReq,
         requestDeserialize: deserialize_aggregator_SetWalletReq,
         responseSerialize: serialize_aggregator_GetWalletResp,
@@ -13263,8 +13489,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_pb25.ListWalletReq,
+        responseType: avs_pb25.ListWalletResp,
         requestSerialize: serialize_aggregator_ListWalletReq,
         requestDeserialize: deserialize_aggregator_ListWalletReq,
         responseSerialize: serialize_aggregator_ListWalletResp,
@@ -13275,8 +13501,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_pb25.CreateTaskReq,
+        responseType: avs_pb25.CreateTaskResp,
         requestSerialize: serialize_aggregator_CreateTaskReq,
         requestDeserialize: deserialize_aggregator_CreateTaskReq,
         responseSerialize: serialize_aggregator_CreateTaskResp,
@@ -13286,8 +13512,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_pb25.ListTasksReq,
+        responseType: avs_pb25.ListTasksResp,
         requestSerialize: serialize_aggregator_ListTasksReq,
         requestDeserialize: deserialize_aggregator_ListTasksReq,
         responseSerialize: serialize_aggregator_ListTasksResp,
@@ -13297,8 +13523,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_pb25.IdReq,
+        responseType: avs_pb25.Task,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
         responseSerialize: serialize_aggregator_Task,
@@ -13308,8 +13534,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_pb25.ListExecutionsReq,
+        responseType: avs_pb25.ListExecutionsResp,
         requestSerialize: serialize_aggregator_ListExecutionsReq,
         requestDeserialize: deserialize_aggregator_ListExecutionsReq,
         responseSerialize: serialize_aggregator_ListExecutionsResp,
@@ -13319,8 +13545,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_pb25.ExecutionReq,
+        responseType: avs_pb25.Execution,
         requestSerialize: serialize_aggregator_ExecutionReq,
         requestDeserialize: deserialize_aggregator_ExecutionReq,
         responseSerialize: serialize_aggregator_Execution,
@@ -13330,8 +13556,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_pb25.ExecutionReq,
+        responseType: avs_pb25.ExecutionStatusResp,
         requestSerialize: serialize_aggregator_ExecutionReq,
         requestDeserialize: deserialize_aggregator_ExecutionReq,
         responseSerialize: serialize_aggregator_ExecutionStatusResp,
@@ -13341,7 +13567,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CancelTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.IdReq,
+        requestType: avs_pb25.IdReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
@@ -13352,7 +13578,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/DeleteTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.IdReq,
+        requestType: avs_pb25.IdReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
@@ -13363,8 +13589,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/TriggerTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.UserTriggerTaskReq,
-        responseType: avs_pb23.UserTriggerTaskResp,
+        requestType: avs_pb25.UserTriggerTaskReq,
+        responseType: avs_pb25.UserTriggerTaskResp,
         requestSerialize: serialize_aggregator_UserTriggerTaskReq,
         requestDeserialize: deserialize_aggregator_UserTriggerTaskReq,
         responseSerialize: serialize_aggregator_UserTriggerTaskResp,
@@ -13377,7 +13603,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CreateSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.CreateOrUpdateSecretReq,
+        requestType: avs_pb25.CreateOrUpdateSecretReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_CreateOrUpdateSecretReq,
         requestDeserialize: deserialize_aggregator_CreateOrUpdateSecretReq,
@@ -13388,7 +13614,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/DeleteSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.DeleteSecretReq,
+        requestType: avs_pb25.DeleteSecretReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_DeleteSecretReq,
         requestDeserialize: deserialize_aggregator_DeleteSecretReq,
@@ -13401,8 +13627,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_pb25.ListSecretsReq,
+        responseType: avs_pb25.ListSecretsResp,
         requestSerialize: serialize_aggregator_ListSecretsReq,
         requestDeserialize: deserialize_aggregator_ListSecretsReq,
         responseSerialize: serialize_aggregator_ListSecretsResp,
@@ -13414,7 +13640,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/UpdateSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb23.CreateOrUpdateSecretReq,
+        requestType: avs_pb25.CreateOrUpdateSecretReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_CreateOrUpdateSecretReq,
         requestDeserialize: deserialize_aggregator_CreateOrUpdateSecretReq,
@@ -13431,8 +13657,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_pb25.GetWorkflowCountReq,
+        responseType: avs_pb25.GetWorkflowCountResp,
         requestSerialize: serialize_aggregator_GetWorkflowCountReq,
         requestDeserialize: deserialize_aggregator_GetWorkflowCountReq,
         responseSerialize: serialize_aggregator_GetWorkflowCountResp,
@@ -13446,8 +13672,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_pb25.GetExecutionCountReq,
+        responseType: avs_pb25.GetExecutionCountResp,
         requestSerialize: serialize_aggregator_GetExecutionCountReq,
         requestDeserialize: deserialize_aggregator_GetExecutionCountReq,
         responseSerialize: serialize_aggregator_GetExecutionCountResp,
@@ -13460,8 +13686,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_pb25.GetExecutionStatsReq,
+        responseType: avs_pb25.GetExecutionStatsResp,
         requestSerialize: serialize_aggregator_GetExecutionStatsReq,
         requestDeserialize: deserialize_aggregator_GetExecutionStatsReq,
         responseSerialize: serialize_aggregator_GetExecutionStatsResp,
@@ -13472,8 +13698,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_pb25.RunNodeWithInputsReq,
+        responseType: avs_pb25.RunNodeWithInputsResp,
         requestSerialize: serialize_aggregator_RunNodeWithInputsReq,
         requestDeserialize: deserialize_aggregator_RunNodeWithInputsReq,
         responseSerialize: serialize_aggregator_RunNodeWithInputsResp,
@@ -13484,8 +13710,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_pb25.RunTriggerReq,
+        responseType: avs_pb25.RunTriggerResp,
         requestSerialize: serialize_aggregator_RunTriggerReq,
         requestDeserialize: deserialize_aggregator_RunTriggerReq,
         responseSerialize: serialize_aggregator_RunTriggerResp,
@@ -13527,14 +13753,13 @@ __export(index_exports, {
   Workflow: () => workflow_default
 });
 module.exports = __toCommonJS(index_exports);
-var import_lodash4 = __toESM(require("lodash"));
 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_pb24 = __toESM(require_avs_pb());
 
 // src/models/workflow.ts
 var import_lodash3 = __toESM(require("lodash"));
-var avs_pb17 = __toESM(require_avs_pb());
+var avs_pb19 = __toESM(require_avs_pb());
 
 // src/models/edge.ts
 var avs_pb = __toESM(require_avs_pb());
@@ -13557,6 +13782,9 @@ var Edge = class _Edge {
 };
 var edge_default = Edge;
 
+// src/models/trigger/factory.ts
+var avs_pb7 = __toESM(require_avs_pb());
+
 // src/models/trigger/block.ts
 var avs_pb2 = __toESM(require_avs_pb());
 
@@ -13627,6 +13855,15 @@ var BlockTrigger2 = class _BlockTrigger extends interface_default {
   getOutput() {
     return this.output;
   }
+  /**
+   * Extract output data from RunTriggerResp for block triggers
+   * @param outputData - The RunTriggerResp containing block trigger output
+   * @returns Plain JavaScript object with block trigger data
+   */
+  static fromOutputData(outputData) {
+    const blockOutput = outputData.getBlockTrigger();
+    return blockOutput?.toObject() || null;
+  }
 };
 var block_default = BlockTrigger2;
 
@@ -13669,13 +13906,22 @@ var CronTrigger2 = class _CronTrigger extends interface_default {
     });
   }
   /**
-   * Convert raw data from runNodeWithInputs response to CronOutput format
+   * Convert raw data from runTrigger response to CronOutput format
    * @param rawData - The raw data from the gRPC response
    * @returns {CronTriggerOutput | undefined} - The converted data
    */
   getOutput() {
     return this.output;
   }
+  /**
+   * Extract output data from RunTriggerResp for cron triggers
+   * @param outputData - The RunTriggerResp containing cron trigger output
+   * @returns Plain JavaScript object with cron trigger data
+   */
+  static fromOutputData(outputData) {
+    const cronOutput = outputData.getCronTrigger();
+    return cronOutput?.toObject() || null;
+  }
 };
 var cron_default = CronTrigger2;
 
@@ -13743,13 +13989,22 @@ var EventTrigger2 = class _EventTrigger extends interface_default {
     });
   }
   /**
-   * Convert raw data from runNodeWithInputs response to EventOutput format
+   * Convert raw data from runTrigger response to EventOutput format
    * @param rawData - The raw data from the gRPC response
    * @returns {EventTriggerOutput | undefined} - The converted data
    */
   getOutput() {
     return this.output;
   }
+  /**
+   * Extract output data from RunTriggerResp for event triggers
+   * @param outputData - The RunTriggerResp containing event trigger output
+   * @returns Plain JavaScript object with event trigger data
+   */
+  static fromOutputData(outputData) {
+    const eventOutput = outputData.getEventTrigger();
+    return eventOutput?.toObject() || null;
+  }
 };
 var event_default = EventTrigger2;
 
@@ -13792,13 +14047,22 @@ var FixedTimeTrigger2 = class _FixedTimeTrigger extends interface_default {
     });
   }
   /**
-   * Convert raw data from runNodeWithInputs response to FixedTimeOutput format
+   * Convert raw data from runTrigger response to FixedTimeOutput format
    * @param rawData - The raw data from the gRPC response
    * @returns {FixedTimeTriggerOutput | undefined} - The converted data
    */
   getOutput() {
     return this.output;
   }
+  /**
+   * Extract output data from RunTriggerResp for fixed time triggers
+   * @param outputData - The RunTriggerResp containing fixed time trigger output
+   * @returns Plain JavaScript object with fixed time trigger data
+   */
+  static fromOutputData(outputData) {
+    const fixedTimeOutput = outputData.getFixedTimeTrigger();
+    return fixedTimeOutput?.toObject() || null;
+  }
 };
 var fixedTime_default = FixedTimeTrigger2;
 
@@ -13828,11 +14092,93 @@ var ManualTrigger = class _ManualTrigger extends interface_default {
   getInputVariables() {
     return this.data;
   }
+  /**
+   * Convert raw data from runTrigger response to ManualOutput format
+   * @param rawData - The raw data from the gRPC response
+   * @returns {ManualTriggerOutput | undefined} - The converted data
+   */
+  getOutput() {
+    return this.output;
+  }
+  /**
+   * Extract output data from RunTriggerResp for manual triggers
+   * @param outputData - The RunTriggerResp containing manual trigger output
+   * @returns Plain JavaScript object with manual trigger data
+   */
+  static fromOutputData(outputData) {
+    const manualOutput = outputData.getManualTrigger();
+    return manualOutput?.toObject() || null;
+  }
 };
 var manual_default = ManualTrigger;
 
 // src/models/trigger/factory.ts
 var import_types6 = require("@avaprotocol/types");
+
+// src/utils.ts
+var import_struct_pb = require("google-protobuf/google/protobuf/struct_pb");
+function convertProtobufValueToJs(value) {
+  if (!value) {
+    return void 0;
+  }
+  switch (value.getKindCase()) {
+    case import_struct_pb.Value.KindCase.NULL_VALUE:
+      return null;
+    case import_struct_pb.Value.KindCase.NUMBER_VALUE:
+      return value.getNumberValue();
+    case import_struct_pb.Value.KindCase.STRING_VALUE:
+      return value.getStringValue();
+    case import_struct_pb.Value.KindCase.BOOL_VALUE:
+      return value.getBoolValue();
+    case import_struct_pb.Value.KindCase.STRUCT_VALUE: {
+      const struct = value.getStructValue();
+      if (!struct) return {};
+      const jsObj = {};
+      const fields = struct.getFieldsMap();
+      fields.forEach((val, key) => {
+        jsObj[key] = convertProtobufValueToJs(val);
+      });
+      return jsObj;
+    }
+    case import_struct_pb.Value.KindCase.LIST_VALUE: {
+      const list = value.getListValue();
+      if (!list) return [];
+      return list.getValuesList().map((item) => convertProtobufValueToJs(item));
+    }
+    case import_struct_pb.Value.KindCase.KIND_NOT_SET:
+    default:
+      return void 0;
+  }
+}
+function convertJSValueToProtobuf(value) {
+  const protobufValue = new import_struct_pb.Value();
+  if (value === null || value === void 0) {
+    protobufValue.setNullValue(0);
+  } else if (typeof value === "number") {
+    protobufValue.setNumberValue(value);
+  } else if (typeof value === "string") {
+    protobufValue.setStringValue(value);
+  } else if (typeof value === "boolean") {
+    protobufValue.setBoolValue(value);
+  } else if (Array.isArray(value)) {
+    const listValue = new import_struct_pb.ListValue();
+    const convertedValues = value.map((item) => convertJSValueToProtobuf(item));
+    listValue.setValuesList(convertedValues);
+    protobufValue.setListValue(listValue);
+  } else if (typeof value === "object") {
+    const structValue = new import_struct_pb.Struct();
+    const fieldsMap = structValue.getFieldsMap();
+    Object.entries(value).forEach(([key, val]) => {
+      fieldsMap.set(key, convertJSValueToProtobuf(val));
+    });
+    protobufValue.setStructValue(structValue);
+  } else {
+    protobufValue.setStringValue(String(value));
+  }
+  return protobufValue;
+}
+
+// src/models/trigger/factory.ts
 var TriggerFactory = class {
   /**
    * Static factory method to create Trigger instances
@@ -13875,14 +14221,51 @@ var TriggerFactory = class {
         throw new Error("Unknown trigger type");
     }
   }
+  static fromOutputData(outputData) {
+    let triggerOutput = null;
+    let rawData = null;
+    switch (outputData.getOutputDataCase()) {
+      case avs_pb7.RunTriggerResp.OutputDataCase.BLOCK_TRIGGER:
+        triggerOutput = outputData.getBlockTrigger();
+        break;
+      case avs_pb7.RunTriggerResp.OutputDataCase.FIXED_TIME_TRIGGER:
+        triggerOutput = outputData.getFixedTimeTrigger();
+        break;
+      case avs_pb7.RunTriggerResp.OutputDataCase.CRON_TRIGGER:
+        triggerOutput = outputData.getCronTrigger();
+        break;
+      case avs_pb7.RunTriggerResp.OutputDataCase.EVENT_TRIGGER:
+        triggerOutput = outputData.getEventTrigger();
+        break;
+      case avs_pb7.RunTriggerResp.OutputDataCase.MANUAL_TRIGGER:
+        triggerOutput = outputData.getManualTrigger();
+        break;
+      case avs_pb7.RunTriggerResp.OutputDataCase.OUTPUT_DATA_NOT_SET:
+      default:
+        throw new Error(
+          `Unsupported output data case: ${outputData.getOutputDataCase()}`
+        );
+    }
+    if (!triggerOutput) {
+      return null;
+    }
+    if (typeof triggerOutput.getData === "function") {
+      rawData = triggerOutput.getData();
+      if (rawData) {
+        return convertProtobufValueToJs(rawData);
+      }
+    }
+    return triggerOutput.toObject();
+  }
 };
 var factory_default = TriggerFactory;
 
 // src/models/node/factory.ts
+var avs_pb18 = __toESM(require_avs_pb());
 var import_lodash2 = __toESM(require("lodash"));
 
 // src/models/node/interface.ts
-var avs_pb7 = __toESM(require_avs_pb());
+var avs_pb8 = __toESM(require_avs_pb());
 var import_types7 = require("@avaprotocol/types");
 var import_lodash = __toESM(require("lodash"));
 var Node = class {
@@ -13893,9 +14276,9 @@ var Node = class {
     this.data = props.data;
   }
   toRequest() {
-    const request = new avs_pb7.TaskNode();
+    const request = new avs_pb8.TaskNode();
     const raw = request.serializeBinary();
-    const parsed = avs_pb7.TaskNode.deserializeBinary(raw);
+    const parsed = avs_pb8.TaskNode.deserializeBinary(raw);
     if (!import_lodash.default.isEqual(request, parsed)) {
       throw new Error("Invalid request object");
     }
@@ -13905,7 +14288,7 @@ var Node = class {
 var interface_default2 = Node;
 
 // src/models/node/contractWrite.ts
-var avs_pb8 = __toESM(require_avs_pb());
+var avs_pb9 = __toESM(require_avs_pb());
 var import_types8 = require("@avaprotocol/types");
 var ContractWriteNode2 = class _ContractWriteNode extends interface_default2 {
   constructor(props) {
@@ -13920,11 +14303,11 @@ var ContractWriteNode2 = class _ContractWriteNode extends interface_default2 {
     });
   }
   toRequest() {
-    const request = new avs_pb8.TaskNode();
+    const request = new avs_pb9.TaskNode();
     request.setId(this.id);
     request.setName(this.name);
-    const nodeData = new avs_pb8.ContractWriteNode();
-    const config = new avs_pb8.ContractWriteNode.Config();
+    const nodeData = new avs_pb9.ContractWriteNode();
+    const config = new avs_pb9.ContractWriteNode.Config();
     config.setContractAddress(this.data.contractAddress);
     config.setCallData(this.data.callData);
     config.setContractAbi(this.data.contractAbi);
@@ -13932,11 +14315,15 @@ var ContractWriteNode2 = class _ContractWriteNode extends interface_default2 {
     request.setContractWrite(nodeData);
     return request;
   }
+  static fromOutputData(outputData) {
+    const contractWriteOutput = outputData.getContractWrite();
+    return contractWriteOutput?.toObject() || null;
+  }
 };
 var contractWrite_default = ContractWriteNode2;
 
 // src/models/node/customCode.ts
-var avs_pb9 = __toESM(require_avs_pb());
+var avs_pb10 = __toESM(require_avs_pb());
 var import_types9 = require("@avaprotocol/types");
 var CustomCodeNode2 = class _CustomCodeNode extends interface_default2 {
   constructor(props) {
@@ -13951,22 +14338,29 @@ var CustomCodeNode2 = class _CustomCodeNode extends interface_default2 {
     });
   }
   toRequest() {
-    const request = new avs_pb9.TaskNode();
+    const request = new avs_pb10.TaskNode();
     request.setId(this.id);
     request.setName(this.name);
-    const nodeData = new avs_pb9.CustomCodeNode();
-    const config = new avs_pb9.CustomCodeNode.Config();
+    const nodeData = new avs_pb10.CustomCodeNode();
+    const config = new avs_pb10.CustomCodeNode.Config();
     config.setLang(this.data.lang);
     config.setSource(this.data.source);
     nodeData.setConfig(config);
     request.setCustomCode(nodeData);
     return request;
   }
+  static fromOutputData(outputData) {
+    const customCodeOutput = outputData.getCustomCode();
+    if (customCodeOutput?.getData()) {
+      return convertProtobufValueToJs(customCodeOutput.getData());
+    }
+    return null;
+  }
 };
 var customCode_default = CustomCodeNode2;
 
 // src/models/node/graphqlQuery.ts
-var avs_pb10 = __toESM(require_avs_pb());
+var avs_pb11 = __toESM(require_avs_pb());
 var import_types10 = require("@avaprotocol/types");
 var GraphQLQueryNode2 = class _GraphQLQueryNode extends interface_default2 {
   constructor(props) {
@@ -13985,11 +14379,11 @@ var GraphQLQueryNode2 = class _GraphQLQueryNode extends interface_default2 {
     });
   }
   toRequest() {
-    const request = new avs_pb10.TaskNode();
+    const request = new avs_pb11.TaskNode();
     request.setId(this.id);
     request.setName(this.name);
-    const nodeData = new avs_pb10.GraphQLQueryNode();
-    const config = new avs_pb10.GraphQLQueryNode.Config();
+    const nodeData = new avs_pb11.GraphQLQueryNode();
+    const config = new avs_pb11.GraphQLQueryNode.Config();
     config.setUrl(this.data.url);
     config.setQuery(this.data.query);
     if (this.data.variablesMap && this.data.variablesMap.length > 0) {
@@ -14002,11 +14396,15 @@ var GraphQLQueryNode2 = class _GraphQLQueryNode extends interface_default2 {
     request.setGraphqlQuery(nodeData);
     return request;
   }
+  static fromOutputData(outputData) {
+    const graphqlOutput = outputData.getGraphql();
+    return graphqlOutput?.toObject() || null;
+  }
 };
 var graphqlQuery_default = GraphQLQueryNode2;
 
 // src/models/node/restApi.ts
-var avs_pb11 = __toESM(require_avs_pb());
+var avs_pb12 = __toESM(require_avs_pb());
 var import_types11 = require("@avaprotocol/types");
 var RestAPINode2 = class _RestAPINode extends interface_default2 {
   constructor(props) {
@@ -14021,29 +14419,43 @@ var RestAPINode2 = class _RestAPINode extends interface_default2 {
     });
   }
   toRequest() {
-    const request = new avs_pb11.TaskNode();
+    const request = new avs_pb12.TaskNode();
     request.setId(this.id);
     request.setName(this.name);
-    const nodeData = new avs_pb11.RestAPINode();
-    const config = new avs_pb11.RestAPINode.Config();
+    const nodeData = new avs_pb12.RestAPINode();
+    const config = new avs_pb12.RestAPINode.Config();
     config.setUrl(this.data.url);
     config.setMethod(this.data.method);
     config.setBody(this.data.body || "");
     if (this.data.headersMap && this.data.headersMap.length > 0) {
       const headersMap = config.getHeadersMap();
-      this.data.headersMap.forEach(([key, value]) => {
-        headersMap.set(key, value);
-      });
+      this.data.headersMap.forEach(
+        ([key, value]) => {
+          headersMap.set(key, value);
+        }
+      );
     }
     nodeData.setConfig(config);
     request.setRestApi(nodeData);
     return request;
   }
+  static fromOutputData(outputData) {
+    const restApiOutput = outputData.getRestApi();
+    if (!restApiOutput) {
+      console.log("Debug RestAPI: No restApiOutput found");
+      return null;
+    }
+    const rawData = restApiOutput.getData();
+    if (rawData) {
+      return convertProtobufValueToJs(rawData);
+    }
+    return restApiOutput.toObject();
+  }
 };
 var restApi_default = RestAPINode2;
 
 // src/models/node/contractRead.ts
-var avs_pb12 = __toESM(require_avs_pb());
+var avs_pb13 = __toESM(require_avs_pb());
 var import_types12 = require("@avaprotocol/types");
 var ContractReadNode2 = class _ContractReadNode extends interface_default2 {
   constructor(props) {
@@ -14058,11 +14470,11 @@ var ContractReadNode2 = class _ContractReadNode extends interface_default2 {
     });
   }
   toRequest() {
-    const request = new avs_pb12.TaskNode();
+    const request = new avs_pb13.TaskNode();
     request.setId(this.id);
     request.setName(this.name);
-    const nodeData = new avs_pb12.ContractReadNode();
-    const config = new avs_pb12.ContractReadNode.Config();
+    const nodeData = new avs_pb13.ContractReadNode();
+    const config = new avs_pb13.ContractReadNode.Config();
     config.setContractAddress(this.data.contractAddress);
     config.setCallData(this.data.callData);
     config.setContractAbi(this.data.contractAbi);
@@ -14070,11 +14482,21 @@ var ContractReadNode2 = class _ContractReadNode extends interface_default2 {
     request.setContractRead(nodeData);
     return request;
   }
+  static fromOutputData(outputData) {
+    const contractReadOutput = outputData.getContractRead();
+    if (contractReadOutput && contractReadOutput.getDataList()) {
+      const dataList = contractReadOutput.getDataList();
+      return {
+        dataList: dataList.map((value) => convertProtobufValueToJs(value))
+      };
+    }
+    return null;
+  }
 };
 var contractRead_default = ContractReadNode2;
 
 // src/models/node/ethTransfer.ts
-var avs_pb13 = __toESM(require_avs_pb());
+var avs_pb14 = __toESM(require_avs_pb());
 var import_types13 = require("@avaprotocol/types");
 var ETHTransferNode2 = class _ETHTransferNode extends interface_default2 {
   constructor(props) {
@@ -14089,23 +14511,27 @@ var ETHTransferNode2 = class _ETHTransferNode extends interface_default2 {
     });
   }
   toRequest() {
-    const request = new avs_pb13.TaskNode();
+    const request = new avs_pb14.TaskNode();
     request.setId(this.id);
     request.setName(this.name);
-    const nodeData = new avs_pb13.ETHTransferNode();
-    const config = new avs_pb13.ETHTransferNode.Config();
+    const nodeData = new avs_pb14.ETHTransferNode();
+    const config = new avs_pb14.ETHTransferNode.Config();
     config.setDestination(this.data.destination);
     config.setAmount(this.data.amount);
     nodeData.setConfig(config);
     request.setEthTransfer(nodeData);
     return request;
   }
+  static fromOutputData(outputData) {
+    const ethTransferOutput = outputData.getEthTransfer();
+    return ethTransferOutput?.toObject() || null;
+  }
 };
 var ethTransfer_default = ETHTransferNode2;
 
 // src/models/node/branch.ts
 var import_types14 = require("@avaprotocol/types");
-var avs_pb14 = __toESM(require_avs_pb());
+var avs_pb15 = __toESM(require_avs_pb());
 var BranchNode2 = class _BranchNode extends interface_default2 {
   constructor(props) {
     super({ ...props, type: import_types14.NodeType.Branch, data: props.data });
@@ -14119,15 +14545,15 @@ var BranchNode2 = class _BranchNode extends interface_default2 {
     });
   }
   toRequest() {
-    const request = new avs_pb14.TaskNode();
+    const request = new avs_pb15.TaskNode();
     request.setId(this.id);
     request.setName(this.name);
-    const nodeData = new avs_pb14.BranchNode();
-    const config = new avs_pb14.BranchNode.Config();
+    const nodeData = new avs_pb15.BranchNode();
+    const config = new avs_pb15.BranchNode.Config();
     if (this.data.conditionsList && this.data.conditionsList.length > 0) {
       const conditionsList = this.data.conditionsList.map(
         (condition) => {
-          const conditionObj = new avs_pb14.BranchNode.Condition();
+          const conditionObj = new avs_pb15.BranchNode.Condition();
           conditionObj.setId(condition.id);
           conditionObj.setType(condition.type);
           conditionObj.setExpression(condition.expression);
@@ -14140,12 +14566,16 @@ var BranchNode2 = class _BranchNode extends interface_default2 {
     request.setBranch(nodeData);
     return request;
   }
+  static fromOutputData(outputData) {
+    const branchOutput = outputData.getBranch();
+    return branchOutput?.toObject() || null;
+  }
   // TODO: do we need a getConditionId() to avoid exporting BranchNodeData?
 };
 var branch_default = BranchNode2;
 
 // src/models/node/filter.ts
-var avs_pb15 = __toESM(require_avs_pb());
+var avs_pb16 = __toESM(require_avs_pb());
 var import_types15 = require("@avaprotocol/types");
 var FilterNode2 = class _FilterNode extends interface_default2 {
   constructor(props) {
@@ -14160,22 +14590,26 @@ var FilterNode2 = class _FilterNode extends interface_default2 {
     });
   }
   toRequest() {
-    const request = new avs_pb15.TaskNode();
+    const request = new avs_pb16.TaskNode();
     request.setId(this.id);
     request.setName(this.name);
-    const nodeData = new avs_pb15.FilterNode();
-    const config = new avs_pb15.FilterNode.Config();
+    const nodeData = new avs_pb16.FilterNode();
+    const config = new avs_pb16.FilterNode.Config();
     config.setExpression(this.data.expression);
     config.setSourceId(this.data.sourceId || "");
     nodeData.setConfig(config);
     request.setFilter(nodeData);
     return request;
   }
+  static fromOutputData(outputData) {
+    const filterOutput = outputData.getFilter();
+    return filterOutput?.toObject() || null;
+  }
 };
 var filter_default = FilterNode2;
 
 // src/models/node/loop.ts
-var avs_pb16 = __toESM(require_avs_pb());
+var avs_pb17 = __toESM(require_avs_pb());
 var import_types16 = require("@avaprotocol/types");
 var LoopNode2 = class _LoopNode extends interface_default2 {
   constructor(props) {
@@ -14206,29 +14640,29 @@ var LoopNode2 = class _LoopNode extends interface_default2 {
     });
   }
   toRequest() {
-    const node = new avs_pb16.TaskNode();
-    const loopNode = new avs_pb16.LoopNode();
+    const node = new avs_pb17.TaskNode();
+    const loopNode = new avs_pb17.LoopNode();
     node.setId(this.id);
     node.setName(this.name);
     const data = this.data;
-    const config = new avs_pb16.LoopNode.Config();
+    const config = new avs_pb17.LoopNode.Config();
     config.setSourceId(data.sourceId || "");
     config.setIterVal(data.iterVal || "");
     config.setIterKey(data.iterKey || "");
     loopNode.setConfig(config);
     if (data.ethTransfer) {
-      const ethTransfer = new avs_pb16.ETHTransferNode();
+      const ethTransfer = new avs_pb17.ETHTransferNode();
       if (data.ethTransfer.config) {
-        const config2 = new avs_pb16.ETHTransferNode.Config();
+        const config2 = new avs_pb17.ETHTransferNode.Config();
         config2.setDestination(data.ethTransfer.config.destination);
         config2.setAmount(data.ethTransfer.config.amount);
         ethTransfer.setConfig(config2);
       }
       loopNode.setEthTransfer(ethTransfer);
     } else if (data.contractWrite) {
-      const contractWrite = new avs_pb16.ContractWriteNode();
+      const contractWrite = new avs_pb17.ContractWriteNode();
       if (data.contractWrite.config) {
-        const config2 = new avs_pb16.ContractWriteNode.Config();
+        const config2 = new avs_pb17.ContractWriteNode.Config();
         config2.setContractAddress(data.contractWrite.config.contractAddress);
         config2.setCallData(data.contractWrite.config.callData);
         config2.setContractAbi(data.contractWrite.config.contractAbi);
@@ -14236,9 +14670,9 @@ var LoopNode2 = class _LoopNode extends interface_default2 {
       }
       loopNode.setContractWrite(contractWrite);
     } else if (data.contractRead) {
-      const contractRead = new avs_pb16.ContractReadNode();
+      const contractRead = new avs_pb17.ContractReadNode();
       if (data.contractRead.config) {
-        const config2 = new avs_pb16.ContractReadNode.Config();
+        const config2 = new avs_pb17.ContractReadNode.Config();
         config2.setContractAddress(data.contractRead.config.contractAddress);
         config2.setCallData(data.contractRead.config.callData);
         config2.setContractAbi(data.contractRead.config.contractAbi);
@@ -14246,9 +14680,9 @@ var LoopNode2 = class _LoopNode extends interface_default2 {
       }
       loopNode.setContractRead(contractRead);
     } else if (data.graphqlDataQuery) {
-      const graphqlQuery = new avs_pb16.GraphQLQueryNode();
+      const graphqlQuery = new avs_pb17.GraphQLQueryNode();
       if (data.graphqlDataQuery.config) {
-        const config2 = new avs_pb16.GraphQLQueryNode.Config();
+        const config2 = new avs_pb17.GraphQLQueryNode.Config();
         config2.setUrl(data.graphqlDataQuery.config.url);
         config2.setQuery(data.graphqlDataQuery.config.query);
         if (data.graphqlDataQuery.config.variablesMap && data.graphqlDataQuery.config.variablesMap.length > 0) {
@@ -14260,9 +14694,9 @@ var LoopNode2 = class _LoopNode extends interface_default2 {
       }
       loopNode.setGraphqlDataQuery(graphqlQuery);
     } else if (data.restApi) {
-      const restApi = new avs_pb16.RestAPINode();
+      const restApi = new avs_pb17.RestAPINode();
       if (data.restApi.config) {
-        const config2 = new avs_pb16.RestAPINode.Config();
+        const config2 = new avs_pb17.RestAPINode.Config();
         config2.setUrl(data.restApi.config.url);
         config2.setMethod(data.restApi.config.method);
         config2.setBody(data.restApi.config.body || "");
@@ -14275,9 +14709,9 @@ var LoopNode2 = class _LoopNode extends interface_default2 {
       }
       loopNode.setRestApi(restApi);
     } else if (data.customCode) {
-      const customCode = new avs_pb16.CustomCodeNode();
+      const customCode = new avs_pb17.CustomCodeNode();
       if (data.customCode.config) {
-        const config2 = new avs_pb16.CustomCodeNode.Config();
+        const config2 = new avs_pb17.CustomCodeNode.Config();
         config2.setLang(data.customCode.config.lang);
         config2.setSource(data.customCode.config.source);
         customCode.setConfig(config2);
@@ -14287,6 +14721,10 @@ var LoopNode2 = class _LoopNode extends interface_default2 {
     node.setLoop(loopNode);
     return node;
   }
+  static fromOutputData(outputData) {
+    const loopOutput = outputData.getLoop();
+    return loopOutput?.toObject() || null;
+  }
 };
 var loop_default = LoopNode2;
 
@@ -14346,6 +14784,52 @@ var NodeFactory = class {
         throw new Error(`Unsupported node type: ${raw.getName()}`);
     }
   }
+  static fromOutputData(outputData) {
+    let nodeOutput = null;
+    let rawData = null;
+    switch (outputData.getOutputDataCase()) {
+      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.REST_API:
+        nodeOutput = outputData.getRestApi();
+        break;
+      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.CUSTOM_CODE:
+        nodeOutput = outputData.getCustomCode();
+        break;
+      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.CONTRACT_READ:
+        nodeOutput = outputData.getContractRead();
+        break;
+      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.CONTRACT_WRITE:
+        nodeOutput = outputData.getContractWrite();
+        break;
+      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.ETH_TRANSFER:
+        nodeOutput = outputData.getEthTransfer();
+        break;
+      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.GRAPHQL:
+        nodeOutput = outputData.getGraphql();
+        break;
+      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.BRANCH:
+        nodeOutput = outputData.getBranch();
+        break;
+      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.FILTER:
+        nodeOutput = outputData.getFilter();
+        break;
+      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.LOOP:
+        nodeOutput = outputData.getLoop();
+        break;
+      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.OUTPUT_DATA_NOT_SET:
+      default:
+        throw new Error(`Unsupported output data case: ${outputData.getOutputDataCase()}`);
+    }
+    if (!nodeOutput) {
+      return null;
+    }
+    if (typeof nodeOutput.getData === "function") {
+      rawData = nodeOutput.getData();
+      if (rawData) {
+        return convertProtobufValueToJs(rawData);
+      }
+    }
+    return nodeOutput.toObject();
+  }
 };
 var factory_default2 = NodeFactory;
 
@@ -14353,11 +14837,11 @@ var factory_default2 = NodeFactory;
 var import_types18 = require("@avaprotocol/types");
 function convertStatusToString(status) {
   const conversionMap = {
-    [avs_pb17.TaskStatus.ACTIVE]: import_types18.WorkflowStatus.Active,
-    [avs_pb17.TaskStatus.COMPLETED]: import_types18.WorkflowStatus.Completed,
-    [avs_pb17.TaskStatus.FAILED]: import_types18.WorkflowStatus.Failed,
-    [avs_pb17.TaskStatus.CANCELED]: import_types18.WorkflowStatus.Canceled,
-    [avs_pb17.TaskStatus.EXECUTING]: import_types18.WorkflowStatus.Executing
+    [avs_pb19.TaskStatus.ACTIVE]: import_types18.WorkflowStatus.Active,
+    [avs_pb19.TaskStatus.COMPLETED]: import_types18.WorkflowStatus.Completed,
+    [avs_pb19.TaskStatus.FAILED]: import_types18.WorkflowStatus.Failed,
+    [avs_pb19.TaskStatus.CANCELED]: import_types18.WorkflowStatus.Canceled,
+    [avs_pb19.TaskStatus.EXECUTING]: import_types18.WorkflowStatus.Executing
   };
   return conversionMap[status];
 }
@@ -14445,7 +14929,7 @@ var Workflow = class _Workflow {
     });
   }
   toRequest() {
-    const request = new avs_pb17.CreateTaskReq();
+    const request = new avs_pb19.CreateTaskReq();
     request.setSmartWalletAddress(this.smartWalletAddress);
     request.setTrigger(this.trigger.toRequest());
     import_lodash3.default.map(this.nodes, (node) => request.addNodes(node.toRequest()));
@@ -14462,19 +14946,19 @@ var Workflow = class _Workflow {
 var workflow_default = Workflow;
 
 // src/models/execution.ts
-var avs_pb20 = __toESM(require_avs_pb());
+var avs_pb22 = __toESM(require_avs_pb());
 
 // src/models/trigger/reason.ts
-var avs_pb18 = __toESM(require_avs_pb());
+var avs_pb20 = __toESM(require_avs_pb());
 var import_types19 = require("@avaprotocol/types");
 var convertTriggerType = (grpcType) => {
   const conversionMap = {
-    [avs_pb18.TriggerType.TRIGGER_TYPE_FIXED_TIME]: import_types19.TriggerType.FixedTime,
-    [avs_pb18.TriggerType.TRIGGER_TYPE_CRON]: import_types19.TriggerType.Cron,
-    [avs_pb18.TriggerType.TRIGGER_TYPE_BLOCK]: import_types19.TriggerType.Block,
-    [avs_pb18.TriggerType.TRIGGER_TYPE_EVENT]: import_types19.TriggerType.Event,
-    [avs_pb18.TriggerType.TRIGGER_TYPE_MANUAL]: import_types19.TriggerType.Manual,
-    [avs_pb18.TriggerType.TRIGGER_TYPE_UNSPECIFIED]: import_types19.TriggerType.Unspecified
+    [avs_pb20.TriggerType.TRIGGER_TYPE_FIXED_TIME]: import_types19.TriggerType.FixedTime,
+    [avs_pb20.TriggerType.TRIGGER_TYPE_CRON]: import_types19.TriggerType.Cron,
+    [avs_pb20.TriggerType.TRIGGER_TYPE_BLOCK]: import_types19.TriggerType.Block,
+    [avs_pb20.TriggerType.TRIGGER_TYPE_EVENT]: import_types19.TriggerType.Event,
+    [avs_pb20.TriggerType.TRIGGER_TYPE_MANUAL]: import_types19.TriggerType.Manual,
+    [avs_pb20.TriggerType.TRIGGER_TYPE_UNSPECIFIED]: import_types19.TriggerType.Unspecified
   };
   return conversionMap[grpcType];
 };
@@ -14514,28 +14998,28 @@ var TriggerReason2 = class _TriggerReason {
     });
   }
   toRequest() {
-    const request = new avs_pb18.TriggerReason();
+    const request = new avs_pb20.TriggerReason();
     switch (this.type) {
       case import_types19.TriggerType.FixedTime:
-        request.setType(avs_pb18.TriggerType.TRIGGER_TYPE_FIXED_TIME);
+        request.setType(avs_pb20.TriggerType.TRIGGER_TYPE_FIXED_TIME);
         if (this.epoch) {
           request.setEpoch(this.epoch);
         }
         break;
       case import_types19.TriggerType.Cron:
-        request.setType(avs_pb18.TriggerType.TRIGGER_TYPE_CRON);
+        request.setType(avs_pb20.TriggerType.TRIGGER_TYPE_CRON);
         if (this.epoch) {
           request.setEpoch(this.epoch);
         }
         break;
       case import_types19.TriggerType.Block:
-        request.setType(avs_pb18.TriggerType.TRIGGER_TYPE_BLOCK);
+        request.setType(avs_pb20.TriggerType.TRIGGER_TYPE_BLOCK);
         if (this.blockNumber) {
           request.setBlockNumber(this.blockNumber);
         }
         break;
       case import_types19.TriggerType.Event:
-        request.setType(avs_pb18.TriggerType.TRIGGER_TYPE_EVENT);
+        request.setType(avs_pb20.TriggerType.TRIGGER_TYPE_EVENT);
         if (this.blockNumber) {
           request.setBlockNumber(this.blockNumber);
         }
@@ -14547,10 +15031,10 @@ var TriggerReason2 = class _TriggerReason {
         }
         break;
       case import_types19.TriggerType.Manual:
-        request.setType(avs_pb18.TriggerType.TRIGGER_TYPE_MANUAL);
+        request.setType(avs_pb20.TriggerType.TRIGGER_TYPE_MANUAL);
         break;
       case import_types19.TriggerType.Unspecified:
-        request.setType(avs_pb18.TriggerType.TRIGGER_TYPE_UNSPECIFIED);
+        request.setType(avs_pb20.TriggerType.TRIGGER_TYPE_UNSPECIFIED);
         break;
       default:
         throw new Error("Unsupported trigger type");
@@ -14561,45 +15045,7 @@ var TriggerReason2 = class _TriggerReason {
 var reason_default = TriggerReason2;
 
 // src/models/step.ts
-var avs_pb19 = __toESM(require_avs_pb());
-
-// src/utils.ts
-var import_struct_pb = require("google-protobuf/google/protobuf/struct_pb");
-function convertProtobufValueToJs(value) {
-  if (!value) {
-    return void 0;
-  }
-  switch (value.getKindCase()) {
-    case import_struct_pb.Value.KindCase.NULL_VALUE:
-      return null;
-    case import_struct_pb.Value.KindCase.NUMBER_VALUE:
-      return value.getNumberValue();
-    case import_struct_pb.Value.KindCase.STRING_VALUE:
-      return value.getStringValue();
-    case import_struct_pb.Value.KindCase.BOOL_VALUE:
-      return value.getBoolValue();
-    case import_struct_pb.Value.KindCase.STRUCT_VALUE: {
-      const struct = value.getStructValue();
-      if (!struct) return {};
-      const jsObj = {};
-      const fields = struct.getFieldsMap();
-      fields.forEach((val, key) => {
-        jsObj[key] = convertProtobufValueToJs(val);
-      });
-      return jsObj;
-    }
-    case import_struct_pb.Value.KindCase.LIST_VALUE: {
-      const list = value.getListValue();
-      if (!list) return [];
-      return list.getValuesList().map((item) => convertProtobufValueToJs(item));
-    }
-    case import_struct_pb.Value.KindCase.KIND_NOT_SET:
-    default:
-      return void 0;
-  }
-}
-
-// src/models/step.ts
+var avs_pb21 = __toESM(require_avs_pb());
 var Step = class _Step {
   // Changed to any
   constructor(props) {
@@ -14616,37 +15062,37 @@ var Step = class _Step {
     const outputDataType = step.getOutputDataCase();
     let nodeOutputMessage;
     switch (outputDataType) {
-      case avs_pb19.Execution.Step.OutputDataCase.OUTPUT_DATA_NOT_SET:
+      case avs_pb21.Execution.Step.OutputDataCase.OUTPUT_DATA_NOT_SET:
         return null;
-      case avs_pb19.Execution.Step.OutputDataCase.ETH_TRANSFER:
+      case avs_pb21.Execution.Step.OutputDataCase.ETH_TRANSFER:
         return step.getEthTransfer()?.toObject();
       // Specific structure, not google.protobuf.Value
-      case avs_pb19.Execution.Step.OutputDataCase.GRAPHQL:
+      case avs_pb21.Execution.Step.OutputDataCase.GRAPHQL:
         nodeOutputMessage = step.getGraphql();
         return nodeOutputMessage && nodeOutputMessage.hasData() ? nodeOutputMessage.getData() : void 0;
-      case avs_pb19.Execution.Step.OutputDataCase.CONTRACT_READ:
+      case avs_pb21.Execution.Step.OutputDataCase.CONTRACT_READ:
         nodeOutputMessage = step.getContractRead();
         if (nodeOutputMessage) {
           return nodeOutputMessage.getDataList().map((val) => convertProtobufValueToJs(val));
         }
         return [];
       // Default to empty array if no data
-      case avs_pb19.Execution.Step.OutputDataCase.CONTRACT_WRITE:
+      case avs_pb21.Execution.Step.OutputDataCase.CONTRACT_WRITE:
         return step.getContractWrite()?.toObject();
       // Specific structure
-      case avs_pb19.Execution.Step.OutputDataCase.CUSTOM_CODE:
+      case avs_pb21.Execution.Step.OutputDataCase.CUSTOM_CODE:
         nodeOutputMessage = step.getCustomCode();
         return nodeOutputMessage && nodeOutputMessage.hasData() ? convertProtobufValueToJs(nodeOutputMessage.getData()) : void 0;
-      case avs_pb19.Execution.Step.OutputDataCase.REST_API:
+      case avs_pb21.Execution.Step.OutputDataCase.REST_API:
         nodeOutputMessage = step.getRestApi();
         return nodeOutputMessage && nodeOutputMessage.hasData() ? nodeOutputMessage.getData() : void 0;
-      case avs_pb19.Execution.Step.OutputDataCase.BRANCH:
+      case avs_pb21.Execution.Step.OutputDataCase.BRANCH:
         return step.getBranch()?.toObject();
       // Specific structure
-      case avs_pb19.Execution.Step.OutputDataCase.FILTER:
+      case avs_pb21.Execution.Step.OutputDataCase.FILTER:
         nodeOutputMessage = step.getFilter();
         return nodeOutputMessage && nodeOutputMessage.hasData() ? nodeOutputMessage.getData() : void 0;
-      case avs_pb19.Execution.Step.OutputDataCase.LOOP:
+      case avs_pb21.Execution.Step.OutputDataCase.LOOP:
         return step.getLoop()?.getData();
       default:
         console.warn(
@@ -14688,19 +15134,19 @@ var Execution3 = class _Execution {
     const triggerOutputDataType = execution.getOutputDataCase();
     let triggerOutputData;
     switch (triggerOutputDataType) {
-      case avs_pb20.Execution.OutputDataCase.BLOCK_TRIGGER:
+      case avs_pb22.Execution.OutputDataCase.BLOCK_TRIGGER:
         const blockOutput = execution.getBlockTrigger()?.toObject();
         triggerOutputData = blockOutput ? { blockNumber: blockOutput.blockNumber } : void 0;
         break;
-      case avs_pb20.Execution.OutputDataCase.FIXED_TIME_TRIGGER:
+      case avs_pb22.Execution.OutputDataCase.FIXED_TIME_TRIGGER:
         const fixedTimeOutput = execution.getFixedTimeTrigger()?.toObject();
         triggerOutputData = fixedTimeOutput ? { epoch: fixedTimeOutput.epoch } : void 0;
         break;
-      case avs_pb20.Execution.OutputDataCase.CRON_TRIGGER:
+      case avs_pb22.Execution.OutputDataCase.CRON_TRIGGER:
         const cronOutput = execution.getCronTrigger()?.toObject();
         triggerOutputData = cronOutput ? { epoch: cronOutput.epoch, scheduleMatched: cronOutput.scheduleMatched } : void 0;
         break;
-      case avs_pb20.Execution.OutputDataCase.EVENT_TRIGGER:
+      case avs_pb22.Execution.OutputDataCase.EVENT_TRIGGER:
         const eventTrigger = execution.getEventTrigger();
         if (eventTrigger) {
           if (eventTrigger.hasEvmLog()) {
@@ -14710,7 +15156,7 @@ var Execution3 = class _Execution {
           }
         }
         break;
-      case avs_pb20.Execution.OutputDataCase.OUTPUT_DATA_NOT_SET:
+      case avs_pb22.Execution.OutputDataCase.OUTPUT_DATA_NOT_SET:
         triggerOutputData = void 0;
         break;
     }
@@ -14731,7 +15177,7 @@ var Execution3 = class _Execution {
 var execution_default = Execution3;
 
 // src/models/secret.ts
-var avs_pb21 = __toESM(require_avs_pb());
+var avs_pb23 = __toESM(require_avs_pb());
 var Secret = class {
   constructor(props) {
     this.name = props.name;
@@ -14744,7 +15190,7 @@ var Secret = class {
     this.description = props.description;
   }
   toRequest() {
-    const request = new avs_pb21.CreateOrUpdateSecretReq();
+    const request = new avs_pb23.CreateOrUpdateSecretReq();
     request.setName(this.name);
     if (this.secret) {
       request.setSecret(this.secret);
@@ -14795,7 +15241,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_pb24.GetSignatureFormatReq();
     request.setWallet(wallet);
     const result = await this.sendGrpcRequest("getSignatureFormat", request);
     return { message: result.getMessage() };
@@ -14810,7 +15256,7 @@ var BaseClient = class {
     message,
     apiKey
   }) {
-    const request = new avs_pb22.GetKeyReq();
+    const request = new avs_pb24.GetKeyReq();
     request.setMessage(message);
     request.setSignature(apiKey);
     const result = await this.sendGrpcRequest("getKey", request);
@@ -14826,7 +15272,7 @@ var BaseClient = class {
     message,
     signature
   }) {
-    const request = new avs_pb22.GetKeyReq();
+    const request = new avs_pb24.GetKeyReq();
     request.setMessage(message);
     request.setSignature(signature);
     const result = await this.sendGrpcRequest(
@@ -14865,112 +15311,32 @@ var BaseClient = class {
     return this.factoryAddress;
   }
   /**
-   * Send a gRPC request with an auth key
-   * @param method - The method name
-   * @param request - The request message
-   * @param options - The request options
-   * @returns {Promise<TResponse>} - The response from the gRPC call
+   * Send a gRPC request with authentication and error handling
+   * @param method - The method name to call
+   * @param request - The request object
+   * @param options - Request options
+   * @returns {Promise<TResponse>} - The response from the server
    */
   sendGrpcRequest(method, request, options) {
-    const metadata = import_lodash4.default.cloneDeep(this.metadata);
-    if (options?.authKey) {
-      metadata.set(import_types21.AUTH_KEY_HEADER, options.authKey);
-    } else if (this.authKey) {
-      metadata.set(import_types21.AUTH_KEY_HEADER, this.authKey);
-    }
     return new Promise((resolve, reject) => {
-      this.rpcClient[method].bind(this.rpcClient)(
+      const metadata = new import_grpc_js.Metadata();
+      const authKey = options?.authKey || this.authKey;
+      if (authKey) {
+        metadata.set(import_types21.AUTH_KEY_HEADER, authKey);
+      }
+      this.rpcClient[method](
         request,
         metadata,
         (error, response) => {
-          if (error) reject(error);
-          else resolve(response);
+          if (error) {
+            reject(error);
+          } else {
+            resolve(response);
+          }
         }
       );
     });
   }
-  /**
-   * Convert a protobuf Value to a JavaScript value
-   * @param value - The protobuf Value object
-   * @returns {any} - The converted JavaScript value
-   */
-  convertProtobufValueToJS(value) {
-    if (!value) return null;
-    if (value.hasNullValue && value.hasNullValue()) {
-      return null;
-    }
-    if (value.hasNumberValue && value.hasNumberValue()) {
-      return value.getNumberValue();
-    }
-    if (value.hasStringValue && value.hasStringValue()) {
-      return value.getStringValue();
-    }
-    if (value.hasBoolValue && value.hasBoolValue()) {
-      return value.getBoolValue();
-    }
-    if (value.hasStructValue && value.hasStructValue()) {
-      const struct = value.getStructValue();
-      const result = {};
-      if (struct && struct.getFieldsMap) {
-        const fieldsMap = struct.getFieldsMap();
-        fieldsMap.forEach((fieldValue, key) => {
-          result[key] = this.convertProtobufValueToJS(fieldValue);
-        });
-      }
-      return result;
-    }
-    if (value.hasListValue && value.hasListValue()) {
-      const list = value.getListValue();
-      if (list && list.getValuesList) {
-        return list.getValuesList().map((item) => this.convertProtobufValueToJS(item));
-      }
-      return [];
-    }
-    if (typeof value.getNumberValue === "function") {
-      return value.getNumberValue();
-    }
-    if (typeof value.getStringValue === "function") {
-      return value.getStringValue();
-    }
-    if (typeof value.getBoolValue === "function") {
-      return value.getBoolValue();
-    }
-    return value;
-  }
-  /**
-   * Convert a JavaScript value to a protobuf Value
-   * @param value - The JavaScript value to convert
-   * @returns {any} - The protobuf Value object
-   */
-  convertJSValueToProtobuf(value) {
-    const protobufValue = new (require("google-protobuf/google/protobuf/struct_pb")).Value();
-    if (value === null || value === void 0) {
-      protobufValue.setNullValue(0);
-    } else if (typeof value === "number") {
-      protobufValue.setNumberValue(value);
-    } else if (typeof value === "string") {
-      protobufValue.setStringValue(value);
-    } else if (typeof value === "boolean") {
-      protobufValue.setBoolValue(value);
-    } else if (Array.isArray(value)) {
-      const listValue = new (require("google-protobuf/google/protobuf/struct_pb")).ListValue();
-      const convertedValues = value.map(
-        (item) => this.convertJSValueToProtobuf(item)
-      );
-      listValue.setValuesList(convertedValues);
-      protobufValue.setListValue(listValue);
-    } else if (typeof value === "object") {
-      const structValue = new (require("google-protobuf/google/protobuf/struct_pb")).Struct();
-      const fieldsMap = structValue.getFieldsMap();
-      Object.entries(value).forEach(([key, val]) => {
-        fieldsMap.set(key, this.convertJSValueToProtobuf(val));
-      });
-      protobufValue.setStructValue(structValue);
-    } else {
-      protobufValue.setStringValue(String(value));
-    }
-    return protobufValue;
-  }
 };
 var Client = class extends BaseClient {
   constructor(config) {
@@ -14982,7 +15348,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_pb24.ListWalletReq();
     const result = await this.sendGrpcRequest("listWallets", request, options);
     return result.getItemsList().map((item) => item.toObject());
   }
@@ -14994,7 +15360,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_pb24.GetWalletReq();
     request.setSalt(salt);
     if (factoryAddress) {
       request.setFactoryAddress(factoryAddress);
@@ -15023,7 +15389,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_pb24.SetWalletReq();
     request.setSalt(salt);
     if (factoryAddress) {
       request.setFactoryAddress(factoryAddress);
@@ -15071,7 +15437,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ items: Workflow[]; pageInfo: PageInfo }>} - The list of Workflow objects with nested pagination metadata
    */
   async getWorkflows(addresses, options) {
-    const request = new avs_pb22.ListTasksReq();
+    const request = new avs_pb24.ListTasksReq();
     for (const a of addresses) {
       request.addSmartWalletAddress(a);
     }
@@ -15110,7 +15476,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_pb24.GetWorkflowCountReq();
     request.setAddressesList(addresses);
     const result = await this.sendGrpcRequest("getWorkflowCount", request, options);
     return result.getTotal();
@@ -15126,7 +15492,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ items: Execution[]; pageInfo: PageInfo }>} - The list of Execution objects with nested pagination metadata
    */
   async getExecutions(workflows, options) {
-    const request = new avs_pb22.ListExecutionsReq();
+    const request = new avs_pb24.ListExecutionsReq();
     for (const w of workflows) {
       request.addTaskIds(w);
     }
@@ -15160,7 +15526,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<Execution>} - The Execution object
    */
   async getExecution(workflowId, executionId, options) {
-    const request = new avs_pb22.ExecutionReq();
+    const request = new avs_pb24.ExecutionReq();
     request.setTaskId(workflowId);
     request.setExecutionId(executionId);
     const result = await this.sendGrpcRequest("getExecution", request, options);
@@ -15173,7 +15539,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_pb24.GetExecutionCountReq();
     request.setWorkflowIdsList(workflows);
     const result = await this.sendGrpcRequest("getExecutionCount", request, options);
     return result.getTotal();
@@ -15186,7 +15552,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_pb24.ExecutionReq();
     request.setTaskId(workflowId);
     request.setExecutionId(executionId);
     const result = await this.sendGrpcRequest("getExecutionStatus", request, options);
@@ -15199,7 +15565,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_pb24.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "getTask",
@@ -15222,7 +15588,7 @@ var Client = class extends BaseClient {
     reason,
     isBlocking = false
   }, options) {
-    const request = new avs_pb22.UserTriggerTaskReq();
+    const request = new avs_pb24.UserTriggerTaskReq();
     request.setTaskId(id);
     request.setReason(new reason_default(reason).toRequest());
     request.setIsBlocking(isBlocking);
@@ -15236,7 +15602,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - Whether the workflow was successfully canceled
    */
   async cancelWorkflow(id, options) {
-    const request = new avs_pb22.IdReq();
+    const request = new avs_pb24.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "cancelTask",
@@ -15252,7 +15618,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - Whether the workflow was successfully deleted
    */
   async deleteWorkflow(id, options) {
-    const request = new avs_pb22.IdReq();
+    const request = new avs_pb24.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "deleteTask",
@@ -15272,7 +15638,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - True if the secret was created successfully
    */
   async createSecret(name, value, options) {
-    const request = new avs_pb22.CreateOrUpdateSecretReq();
+    const request = new avs_pb24.CreateOrUpdateSecretReq();
     request.setName(name);
     request.setSecret(value);
     if (options?.workflowId) {
@@ -15295,7 +15661,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - True if the secret was updated successfully
    */
   async updateSecret(name, value, options) {
-    const request = new avs_pb22.CreateOrUpdateSecretReq();
+    const request = new avs_pb24.CreateOrUpdateSecretReq();
     request.setName(name);
     request.setSecret(value);
     if (options?.workflowId) {
@@ -15322,7 +15688,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_pb24.ListSecretsReq();
     if (options?.workflowId) {
       request.setWorkflowId(options.workflowId);
     }
@@ -15377,7 +15743,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - True if the secret was deleted successfully
    */
   async deleteSecret(name, options) {
-    const request = new avs_pb22.DeleteSecretReq();
+    const request = new avs_pb24.DeleteSecretReq();
     request.setName(name);
     if (options?.workflowId) {
       request.setWorkflowId(options.workflowId);
@@ -15398,80 +15764,40 @@ var Client = class extends BaseClient {
    * @returns {Promise<RunNodeWithInputsResponse>} - The response from running the node
    */
   async runNodeWithInputs({ nodeType, nodeConfig, inputVariables = {} }, options) {
-    try {
-      const triggerTypes = [
-        import_types20.TriggerType.Block,
-        import_types20.TriggerType.FixedTime,
-        import_types20.TriggerType.Cron,
-        import_types20.TriggerType.Event,
-        import_types20.TriggerType.Manual
-      ];
-      if (triggerTypes.includes(nodeType)) {
-        return {
-          success: false,
-          error: `Trigger type "${nodeType}" should use the runTrigger() method instead of runNodeWithInputs()`,
-          nodeId: ""
-        };
-      }
-      const request = new avs_pb22.RunNodeWithInputsReq();
-      const protobufNodeType = import_types20.NodeTypeGoConverter.fromGoString(nodeType);
-      request.setNodeType(protobufNodeType);
-      const nodeConfigMap = request.getNodeConfigMap();
-      for (const [key, value] of Object.entries(nodeConfig)) {
-        nodeConfigMap.set(key, this.convertJSValueToProtobuf(value));
-      }
-      if (inputVariables && Object.keys(inputVariables).length > 0) {
-        const inputVarsMap = request.getInputVariablesMap();
-        for (const [key, value] of Object.entries(inputVariables)) {
-          inputVarsMap.set(key, this.convertJSValueToProtobuf(value));
-        }
-      }
-      const result = await this.sendGrpcRequest("runNodeWithInputs", request, options);
-      let data;
-      const outputCase = result.getOutputDataCase();
-      if (outputCase !== avs_pb22.RunNodeWithInputsResp.OutputDataCase.OUTPUT_DATA_NOT_SET) {
-        switch (outputCase) {
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.ETH_TRANSFER:
-            data = result.getEthTransfer()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.GRAPHQL:
-            data = result.getGraphql()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.CONTRACT_READ:
-            data = result.getContractRead()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.CONTRACT_WRITE:
-            data = result.getContractWrite()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.CUSTOM_CODE:
-            data = result.getCustomCode()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.REST_API:
-            data = result.getRestApi()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.BRANCH:
-            data = result.getBranch()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.FILTER:
-            data = result.getFilter()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.LOOP:
-            data = result.getLoop()?.toObject();
-            break;
-        }
-      }
-      return {
-        success: result.getSuccess(),
-        data,
-        error: result.getError(),
-        nodeId: result.getNodeId()
-      };
-    } catch (error) {
+    const triggerTypes = [
+      import_types20.TriggerType.Block,
+      import_types20.TriggerType.FixedTime,
+      import_types20.TriggerType.Cron,
+      import_types20.TriggerType.Event,
+      import_types20.TriggerType.Manual
+    ];
+    if (triggerTypes.includes(nodeType)) {
       return {
         success: false,
-        error: error.message || "An error occurred"
+        error: `Trigger type "${nodeType}" should use the runTrigger() method instead of runNodeWithInputs()`,
+        nodeId: ""
       };
     }
+    const request = new avs_pb24.RunNodeWithInputsReq();
+    const protobufNodeType = import_types20.NodeTypeGoConverter.fromGoString(nodeType);
+    request.setNodeType(protobufNodeType);
+    const nodeConfigMap = request.getNodeConfigMap();
+    for (const [key, value] of Object.entries(nodeConfig)) {
+      nodeConfigMap.set(key, convertJSValueToProtobuf(value));
+    }
+    if (inputVariables && Object.keys(inputVariables).length > 0) {
+      const inputVarsMap = request.getInputVariablesMap();
+      for (const [key, value] of Object.entries(inputVariables)) {
+        inputVarsMap.set(key, convertJSValueToProtobuf(value));
+      }
+    }
+    const result = await this.sendGrpcRequest("runNodeWithInputs", request, options);
+    return {
+      success: result.getSuccess(),
+      data: factory_default2.fromOutputData(result),
+      error: result.getError(),
+      nodeId: result.getNodeId()
+    };
   }
   /**
    * Run a trigger for testing purposes
@@ -15482,45 +15808,20 @@ var Client = class extends BaseClient {
    * @returns {Promise<RunTriggerResponse>} - The response from running the trigger
    */
   async runTrigger({ triggerType, triggerConfig }, options) {
-    try {
-      const request = new avs_pb22.RunTriggerReq();
-      const protobufTriggerType = import_types20.TriggerTypeGoConverter.fromGoString(triggerType);
-      request.setTriggerType(protobufTriggerType);
-      const triggerConfigMap = request.getTriggerConfigMap();
-      for (const [key, value] of Object.entries(triggerConfig)) {
-        triggerConfigMap.set(key, this.convertJSValueToProtobuf(value));
-      }
-      const result = await this.sendGrpcRequest("runTrigger", request, options);
-      let data;
-      const outputCase = result.getOutputDataCase();
-      if (outputCase !== avs_pb22.RunTriggerResp.OutputDataCase.OUTPUT_DATA_NOT_SET) {
-        switch (outputCase) {
-          case avs_pb22.RunTriggerResp.OutputDataCase.BLOCK_TRIGGER:
-            data = result.getBlockTrigger()?.toObject();
-            break;
-          case avs_pb22.RunTriggerResp.OutputDataCase.FIXED_TIME_TRIGGER:
-            data = result.getFixedTimeTrigger()?.toObject();
-            break;
-          case avs_pb22.RunTriggerResp.OutputDataCase.CRON_TRIGGER:
-            data = result.getCronTrigger()?.toObject();
-            break;
-          case avs_pb22.RunTriggerResp.OutputDataCase.EVENT_TRIGGER:
-            data = result.getEventTrigger()?.toObject();
-            break;
-        }
-      }
-      return {
-        success: result.getSuccess(),
-        data,
-        error: result.getError(),
-        triggerId: result.getTriggerId()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message || "An error occurred"
-      };
-    }
+    const request = new avs_pb24.RunTriggerReq();
+    const protobufTriggerType = import_types20.TriggerTypeGoConverter.fromGoString(triggerType);
+    request.setTriggerType(protobufTriggerType);
+    const triggerConfigMap = request.getTriggerConfigMap();
+    for (const [key, value] of Object.entries(triggerConfig)) {
+      triggerConfigMap.set(key, convertJSValueToProtobuf(value));
+    }
+    const result = await this.sendGrpcRequest("runTrigger", request, options);
+    return {
+      success: result.getSuccess(),
+      data: factory_default.fromOutputData(result),
+      error: result.getError(),
+      triggerId: result.getTriggerId()
+    };
   }
 };
 // Annotate the CommonJS export names for ESM import in node: