@avaprotocol/sdk-js 1.6.5 → 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);
@@ -147,6 +150,9 @@ var require_avs_pb = __commonJS({
     goog.exportSymbol("proto.aggregator.RunNodeWithInputsReq", null, global);
     goog.exportSymbol("proto.aggregator.RunNodeWithInputsResp", null, global);
     goog.exportSymbol("proto.aggregator.RunNodeWithInputsResp.OutputDataCase", null, global);
+    goog.exportSymbol("proto.aggregator.RunTriggerReq", null, global);
+    goog.exportSymbol("proto.aggregator.RunTriggerResp", null, global);
+    goog.exportSymbol("proto.aggregator.RunTriggerResp.OutputDataCase", null, global);
     goog.exportSymbol("proto.aggregator.Secret", null, global);
     goog.exportSymbol("proto.aggregator.SetWalletReq", null, global);
     goog.exportSymbol("proto.aggregator.SmartWallet", null, global);
@@ -266,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_);
     };
@@ -763,6 +790,20 @@ var require_avs_pb = __commonJS({
     if (goog.DEBUG && !COMPILED) {
       proto.aggregator.RunNodeWithInputsResp.displayName = "proto.aggregator.RunNodeWithInputsResp";
     }
+    proto.aggregator.RunTriggerReq = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.RunTriggerReq, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.RunTriggerReq.displayName = "proto.aggregator.RunTriggerReq";
+    }
+    proto.aggregator.RunTriggerResp = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, proto.aggregator.RunTriggerResp.oneofGroups_);
+    };
+    goog.inherits(proto.aggregator.RunTriggerResp, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.RunTriggerResp.displayName = "proto.aggregator.RunTriggerResp";
+    }
     proto.aggregator.Evm = function(opt_data) {
       jspb.Message.initialize(this, opt_data, 0, -1, null, null);
     };
@@ -2342,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,
@@ -3821,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;
@@ -3842,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:
@@ -3865,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) {
@@ -10964,7 +11177,7 @@ var require_avs_pb = __commonJS({
       this.getInputVariablesMap().clear();
       return this;
     };
-    proto.aggregator.RunNodeWithInputsResp.oneofGroups_ = [[10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23]];
+    proto.aggregator.RunNodeWithInputsResp.oneofGroups_ = [[10, 11, 12, 13, 14, 15, 16, 17, 18]];
     proto.aggregator.RunNodeWithInputsResp.OutputDataCase = {
       OUTPUT_DATA_NOT_SET: 0,
       ETH_TRANSFER: 10,
@@ -10975,11 +11188,7 @@ var require_avs_pb = __commonJS({
       REST_API: 15,
       BRANCH: 16,
       FILTER: 17,
-      LOOP: 18,
-      BLOCK_TRIGGER: 20,
-      FIXED_TIME_TRIGGER: 21,
-      CRON_TRIGGER: 22,
-      EVENT_TRIGGER: 23
+      LOOP: 18
     };
     proto.aggregator.RunNodeWithInputsResp.prototype.getOutputDataCase = function() {
       return (
@@ -11004,11 +11213,7 @@ var require_avs_pb = __commonJS({
           restApi: (f = msg.getRestApi()) && proto.aggregator.RestAPINode.Output.toObject(includeInstance, f),
           branch: (f = msg.getBranch()) && proto.aggregator.BranchNode.Output.toObject(includeInstance, f),
           filter: (f = msg.getFilter()) && proto.aggregator.FilterNode.Output.toObject(includeInstance, f),
-          loop: (f = msg.getLoop()) && proto.aggregator.LoopNode.Output.toObject(includeInstance, f),
-          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)
+          loop: (f = msg.getLoop()) && proto.aggregator.LoopNode.Output.toObject(includeInstance, f)
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -11094,26 +11299,6 @@ var require_avs_pb = __commonJS({
             reader.readMessage(value, proto.aggregator.LoopNode.Output.deserializeBinaryFromReader);
             msg.setLoop(value);
             break;
-          case 20:
-            var value = new proto.aggregator.BlockTrigger.Output();
-            reader.readMessage(value, proto.aggregator.BlockTrigger.Output.deserializeBinaryFromReader);
-            msg.setBlockTrigger(value);
-            break;
-          case 21:
-            var value = new proto.aggregator.FixedTimeTrigger.Output();
-            reader.readMessage(value, proto.aggregator.FixedTimeTrigger.Output.deserializeBinaryFromReader);
-            msg.setFixedTimeTrigger(value);
-            break;
-          case 22:
-            var value = new proto.aggregator.CronTrigger.Output();
-            reader.readMessage(value, proto.aggregator.CronTrigger.Output.deserializeBinaryFromReader);
-            msg.setCronTrigger(value);
-            break;
-          case 23:
-            var value = new proto.aggregator.EventTrigger.Output();
-            reader.readMessage(value, proto.aggregator.EventTrigger.Output.deserializeBinaryFromReader);
-            msg.setEventTrigger(value);
-            break;
           default:
             reader.skipField();
             break;
@@ -11221,38 +11406,6 @@ var require_avs_pb = __commonJS({
           proto.aggregator.LoopNode.Output.serializeBinaryToWriter
         );
       }
-      f = message.getBlockTrigger();
-      if (f != null) {
-        writer.writeMessage(
-          20,
-          f,
-          proto.aggregator.BlockTrigger.Output.serializeBinaryToWriter
-        );
-      }
-      f = message.getFixedTimeTrigger();
-      if (f != null) {
-        writer.writeMessage(
-          21,
-          f,
-          proto.aggregator.FixedTimeTrigger.Output.serializeBinaryToWriter
-        );
-      }
-      f = message.getCronTrigger();
-      if (f != null) {
-        writer.writeMessage(
-          22,
-          f,
-          proto.aggregator.CronTrigger.Output.serializeBinaryToWriter
-        );
-      }
-      f = message.getEventTrigger();
-      if (f != null) {
-        writer.writeMessage(
-          23,
-          f,
-          proto.aggregator.EventTrigger.Output.serializeBinaryToWriter
-        );
-      }
     };
     proto.aggregator.RunNodeWithInputsResp.prototype.getSuccess = function() {
       return (
@@ -11416,92 +11569,394 @@ var require_avs_pb = __commonJS({
     proto.aggregator.RunNodeWithInputsResp.prototype.hasLoop = function() {
       return jspb.Message.getField(this, 18) != null;
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.getBlockTrigger = function() {
-      return (
-        /** @type{?proto.aggregator.BlockTrigger.Output} */
-        jspb.Message.getWrapperField(this, proto.aggregator.BlockTrigger.Output, 20)
-      );
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.setBlockTrigger = function(value) {
-      return jspb.Message.setOneofWrapperField(this, 20, proto.aggregator.RunNodeWithInputsResp.oneofGroups_[0], value);
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.clearBlockTrigger = function() {
-      return this.setBlockTrigger(void 0);
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.hasBlockTrigger = function() {
-      return jspb.Message.getField(this, 20) != null;
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.getFixedTimeTrigger = function() {
-      return (
-        /** @type{?proto.aggregator.FixedTimeTrigger.Output} */
-        jspb.Message.getWrapperField(this, proto.aggregator.FixedTimeTrigger.Output, 21)
-      );
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.setFixedTimeTrigger = function(value) {
-      return jspb.Message.setOneofWrapperField(this, 21, proto.aggregator.RunNodeWithInputsResp.oneofGroups_[0], value);
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.clearFixedTimeTrigger = function() {
-      return this.setFixedTimeTrigger(void 0);
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.hasFixedTimeTrigger = function() {
-      return jspb.Message.getField(this, 21) != null;
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.getCronTrigger = function() {
-      return (
-        /** @type{?proto.aggregator.CronTrigger.Output} */
-        jspb.Message.getWrapperField(this, proto.aggregator.CronTrigger.Output, 22)
-      );
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.setCronTrigger = function(value) {
-      return jspb.Message.setOneofWrapperField(this, 22, proto.aggregator.RunNodeWithInputsResp.oneofGroups_[0], value);
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.clearCronTrigger = function() {
-      return this.setCronTrigger(void 0);
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.hasCronTrigger = function() {
-      return jspb.Message.getField(this, 22) != null;
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.getEventTrigger = function() {
-      return (
-        /** @type{?proto.aggregator.EventTrigger.Output} */
-        jspb.Message.getWrapperField(this, proto.aggregator.EventTrigger.Output, 23)
-      );
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.setEventTrigger = function(value) {
-      return jspb.Message.setOneofWrapperField(this, 23, proto.aggregator.RunNodeWithInputsResp.oneofGroups_[0], value);
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.clearEventTrigger = function() {
-      return this.setEventTrigger(void 0);
-    };
-    proto.aggregator.RunNodeWithInputsResp.prototype.hasEventTrigger = function() {
-      return jspb.Message.getField(this, 23) != null;
-    };
     if (jspb.Message.GENERATE_TO_OBJECT) {
-      proto.aggregator.Evm.prototype.toObject = function(opt_includeInstance) {
-        return proto.aggregator.Evm.toObject(opt_includeInstance, this);
+      proto.aggregator.RunTriggerReq.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.RunTriggerReq.toObject(opt_includeInstance, this);
       };
-      proto.aggregator.Evm.toObject = function(includeInstance, msg) {
-        var f, obj = {};
+      proto.aggregator.RunTriggerReq.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          triggerType: jspb.Message.getFieldWithDefault(msg, 1, 0),
+          triggerConfigMap: (f = msg.getTriggerConfigMap()) ? f.toObject(includeInstance, proto.google.protobuf.Value.toObject) : []
+        };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
         }
         return obj;
       };
     }
-    proto.aggregator.Evm.deserializeBinary = function(bytes) {
+    proto.aggregator.RunTriggerReq.deserializeBinary = function(bytes) {
       var reader = new jspb.BinaryReader(bytes);
-      var msg = new proto.aggregator.Evm();
-      return proto.aggregator.Evm.deserializeBinaryFromReader(msg, reader);
+      var msg = new proto.aggregator.RunTriggerReq();
+      return proto.aggregator.RunTriggerReq.deserializeBinaryFromReader(msg, reader);
     };
-    proto.aggregator.Evm.deserializeBinaryFromReader = function(msg, reader) {
+    proto.aggregator.RunTriggerReq.deserializeBinaryFromReader = function(msg, reader) {
       while (reader.nextField()) {
         if (reader.isEndGroup()) {
           break;
         }
         var field = reader.getFieldNumber();
         switch (field) {
-          default:
-            reader.skipField();
+          case 1:
+            var value = (
+              /** @type {!proto.aggregator.TriggerType} */
+              reader.readEnum()
+            );
+            msg.setTriggerType(value);
+            break;
+          case 2:
+            var value = msg.getTriggerConfigMap();
+            reader.readMessage(value, function(message, reader2) {
+              jspb.Map.deserializeBinary(message, reader2, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.google.protobuf.Value.deserializeBinaryFromReader, "", new proto.google.protobuf.Value());
+            });
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.RunTriggerReq.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.RunTriggerReq.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.RunTriggerReq.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getTriggerType();
+      if (f !== 0) {
+        writer.writeEnum(
+          1,
+          f
+        );
+      }
+      f = message.getTriggerConfigMap(true);
+      if (f && f.getLength() > 0) {
+        f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.google.protobuf.Value.serializeBinaryToWriter);
+      }
+    };
+    proto.aggregator.RunTriggerReq.prototype.getTriggerType = function() {
+      return (
+        /** @type {!proto.aggregator.TriggerType} */
+        jspb.Message.getFieldWithDefault(this, 1, 0)
+      );
+    };
+    proto.aggregator.RunTriggerReq.prototype.setTriggerType = function(value) {
+      return jspb.Message.setProto3EnumField(this, 1, value);
+    };
+    proto.aggregator.RunTriggerReq.prototype.getTriggerConfigMap = function(opt_noLazyCreate) {
+      return (
+        /** @type {!jspb.Map<string,!proto.google.protobuf.Value>} */
+        jspb.Message.getMapField(
+          this,
+          2,
+          opt_noLazyCreate,
+          proto.google.protobuf.Value
+        )
+      );
+    };
+    proto.aggregator.RunTriggerReq.prototype.clearTriggerConfigMap = function() {
+      this.getTriggerConfigMap().clear();
+      return this;
+    };
+    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,
+      MANUAL_TRIGGER: 14
+    };
+    proto.aggregator.RunTriggerResp.prototype.getOutputDataCase = function() {
+      return (
+        /** @type {proto.aggregator.RunTriggerResp.OutputDataCase} */
+        jspb.Message.computeOneofCase(this, proto.aggregator.RunTriggerResp.oneofGroups_[0])
+      );
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.RunTriggerResp.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.RunTriggerResp.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.RunTriggerResp.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          success: jspb.Message.getBooleanFieldWithDefault(msg, 1, false),
+          error: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          triggerId: jspb.Message.getFieldWithDefault(msg, 3, ""),
+          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),
+          manualTrigger: (f = msg.getManualTrigger()) && proto.aggregator.ManualTrigger.Output.toObject(includeInstance, f)
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.RunTriggerResp.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.RunTriggerResp();
+      return proto.aggregator.RunTriggerResp.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.RunTriggerResp.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = (
+              /** @type {boolean} */
+              reader.readBool()
+            );
+            msg.setSuccess(value);
+            break;
+          case 2:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setError(value);
+            break;
+          case 3:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setTriggerId(value);
+            break;
+          case 10:
+            var value = new proto.aggregator.BlockTrigger.Output();
+            reader.readMessage(value, proto.aggregator.BlockTrigger.Output.deserializeBinaryFromReader);
+            msg.setBlockTrigger(value);
+            break;
+          case 11:
+            var value = new proto.aggregator.FixedTimeTrigger.Output();
+            reader.readMessage(value, proto.aggregator.FixedTimeTrigger.Output.deserializeBinaryFromReader);
+            msg.setFixedTimeTrigger(value);
+            break;
+          case 12:
+            var value = new proto.aggregator.CronTrigger.Output();
+            reader.readMessage(value, proto.aggregator.CronTrigger.Output.deserializeBinaryFromReader);
+            msg.setCronTrigger(value);
+            break;
+          case 13:
+            var value = new proto.aggregator.EventTrigger.Output();
+            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;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.RunTriggerResp.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.RunTriggerResp.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.RunTriggerResp.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getSuccess();
+      if (f) {
+        writer.writeBool(
+          1,
+          f
+        );
+      }
+      f = message.getError();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
+      }
+      f = message.getTriggerId();
+      if (f.length > 0) {
+        writer.writeString(
+          3,
+          f
+        );
+      }
+      f = message.getBlockTrigger();
+      if (f != null) {
+        writer.writeMessage(
+          10,
+          f,
+          proto.aggregator.BlockTrigger.Output.serializeBinaryToWriter
+        );
+      }
+      f = message.getFixedTimeTrigger();
+      if (f != null) {
+        writer.writeMessage(
+          11,
+          f,
+          proto.aggregator.FixedTimeTrigger.Output.serializeBinaryToWriter
+        );
+      }
+      f = message.getCronTrigger();
+      if (f != null) {
+        writer.writeMessage(
+          12,
+          f,
+          proto.aggregator.CronTrigger.Output.serializeBinaryToWriter
+        );
+      }
+      f = message.getEventTrigger();
+      if (f != null) {
+        writer.writeMessage(
+          13,
+          f,
+          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 (
+        /** @type {boolean} */
+        jspb.Message.getBooleanFieldWithDefault(this, 1, false)
+      );
+    };
+    proto.aggregator.RunTriggerResp.prototype.setSuccess = function(value) {
+      return jspb.Message.setProto3BooleanField(this, 1, value);
+    };
+    proto.aggregator.RunTriggerResp.prototype.getError = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
+      );
+    };
+    proto.aggregator.RunTriggerResp.prototype.setError = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
+    };
+    proto.aggregator.RunTriggerResp.prototype.getTriggerId = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 3, "")
+      );
+    };
+    proto.aggregator.RunTriggerResp.prototype.setTriggerId = function(value) {
+      return jspb.Message.setProto3StringField(this, 3, value);
+    };
+    proto.aggregator.RunTriggerResp.prototype.getBlockTrigger = function() {
+      return (
+        /** @type{?proto.aggregator.BlockTrigger.Output} */
+        jspb.Message.getWrapperField(this, proto.aggregator.BlockTrigger.Output, 10)
+      );
+    };
+    proto.aggregator.RunTriggerResp.prototype.setBlockTrigger = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 10, proto.aggregator.RunTriggerResp.oneofGroups_[0], value);
+    };
+    proto.aggregator.RunTriggerResp.prototype.clearBlockTrigger = function() {
+      return this.setBlockTrigger(void 0);
+    };
+    proto.aggregator.RunTriggerResp.prototype.hasBlockTrigger = function() {
+      return jspb.Message.getField(this, 10) != null;
+    };
+    proto.aggregator.RunTriggerResp.prototype.getFixedTimeTrigger = function() {
+      return (
+        /** @type{?proto.aggregator.FixedTimeTrigger.Output} */
+        jspb.Message.getWrapperField(this, proto.aggregator.FixedTimeTrigger.Output, 11)
+      );
+    };
+    proto.aggregator.RunTriggerResp.prototype.setFixedTimeTrigger = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 11, proto.aggregator.RunTriggerResp.oneofGroups_[0], value);
+    };
+    proto.aggregator.RunTriggerResp.prototype.clearFixedTimeTrigger = function() {
+      return this.setFixedTimeTrigger(void 0);
+    };
+    proto.aggregator.RunTriggerResp.prototype.hasFixedTimeTrigger = function() {
+      return jspb.Message.getField(this, 11) != null;
+    };
+    proto.aggregator.RunTriggerResp.prototype.getCronTrigger = function() {
+      return (
+        /** @type{?proto.aggregator.CronTrigger.Output} */
+        jspb.Message.getWrapperField(this, proto.aggregator.CronTrigger.Output, 12)
+      );
+    };
+    proto.aggregator.RunTriggerResp.prototype.setCronTrigger = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 12, proto.aggregator.RunTriggerResp.oneofGroups_[0], value);
+    };
+    proto.aggregator.RunTriggerResp.prototype.clearCronTrigger = function() {
+      return this.setCronTrigger(void 0);
+    };
+    proto.aggregator.RunTriggerResp.prototype.hasCronTrigger = function() {
+      return jspb.Message.getField(this, 12) != null;
+    };
+    proto.aggregator.RunTriggerResp.prototype.getEventTrigger = function() {
+      return (
+        /** @type{?proto.aggregator.EventTrigger.Output} */
+        jspb.Message.getWrapperField(this, proto.aggregator.EventTrigger.Output, 13)
+      );
+    };
+    proto.aggregator.RunTriggerResp.prototype.setEventTrigger = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 13, proto.aggregator.RunTriggerResp.oneofGroups_[0], value);
+    };
+    proto.aggregator.RunTriggerResp.prototype.clearEventTrigger = function() {
+      return this.setEventTrigger(void 0);
+    };
+    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);
+      };
+      proto.aggregator.Evm.toObject = function(includeInstance, msg) {
+        var f, obj = {};
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.Evm.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.Evm();
+      return proto.aggregator.Evm.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.Evm.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          default:
+            reader.skipField();
             break;
         }
       }
@@ -12615,334 +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_pb25.RunTriggerReq)) {
+        throw new Error("Expected argument of type aggregator.RunTriggerReq");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
+    function deserialize_aggregator_RunTriggerReq(buffer_arg) {
+      return avs_pb25.RunTriggerReq.deserializeBinary(new Uint8Array(buffer_arg));
+    }
+    function serialize_aggregator_RunTriggerResp(arg) {
+      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_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)) {
@@ -12959,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,
@@ -12971,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,
@@ -12983,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,
@@ -12994,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,
@@ -13005,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,
@@ -13016,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,
@@ -13028,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,
@@ -13039,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,
@@ -13050,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,
@@ -13061,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,
@@ -13072,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,
@@ -13083,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,
@@ -13094,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,
@@ -13105,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,
@@ -13116,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,
@@ -13130,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,
@@ -13141,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,
@@ -13154,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,
@@ -13167,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,
@@ -13184,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,
@@ -13199,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,
@@ -13213,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,
@@ -13225,12 +13698,24 @@ 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,
         responseDeserialize: deserialize_aggregator_RunNodeWithInputsResp
+      },
+      // RunTrigger allows executing a single trigger for testing purposes (triggers don't accept inputs)
+      runTrigger: {
+        path: "/aggregator.Aggregator/RunTrigger",
+        requestStream: false,
+        responseStream: false,
+        requestType: avs_pb25.RunTriggerReq,
+        responseType: avs_pb25.RunTriggerResp,
+        requestSerialize: serialize_aggregator_RunTriggerReq,
+        requestDeserialize: deserialize_aggregator_RunTriggerReq,
+        responseSerialize: serialize_aggregator_RunTriggerResp,
+        responseDeserialize: deserialize_aggregator_RunTriggerResp
       }
     };
     exports2.AggregatorClient = grpc.makeGenericClientConstructor(AggregatorService, "Aggregator");
@@ -13268,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());
@@ -13298,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());
 
@@ -13368,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;
 
@@ -13410,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;
 
@@ -13484,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;
 
@@ -13533,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;
 
@@ -13557,23 +14080,105 @@ var ManualTrigger = class _ManualTrigger extends interface_default {
     trigger.setManual(true);
     return trigger;
   }
-  static fromResponse(raw) {
-    const obj = raw.toObject();
-    return new _ManualTrigger({
-      ...obj,
-      type: import_types5.TriggerType.Manual,
-      data: null
-      // Manual triggers don't have data in the protobuf response
+  static fromResponse(raw) {
+    const obj = raw.toObject();
+    return new _ManualTrigger({
+      ...obj,
+      type: import_types5.TriggerType.Manual,
+      data: null
+      // Manual triggers don't have data in the protobuf response
+    });
+  }
+  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));
   }
-  getInputVariables() {
-    return this.data;
-  }
-};
-var manual_default = ManualTrigger;
+  return protobufValue;
+}
 
 // src/models/trigger/factory.ts
-var import_types6 = require("@avaprotocol/types");
 var TriggerFactory = class {
   /**
    * Static factory method to create Trigger instances
@@ -13616,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 {
@@ -13634,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");
     }
@@ -13646,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) {
@@ -13661,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);
@@ -13673,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) {
@@ -13692,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) {
@@ -13726,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) {
@@ -13743,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) {
@@ -13762,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) {
@@ -13799,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);
@@ -13811,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) {
@@ -13830,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 });
@@ -13860,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);
@@ -13881,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) {
@@ -13901,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) {
@@ -13947,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);
@@ -13977,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);
@@ -13987,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) {
@@ -14001,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 || "");
@@ -14016,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);
@@ -14028,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;
 
@@ -14087,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;
 
@@ -14094,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];
 }
@@ -14186,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()));
@@ -14203,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];
 };
@@ -14255,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);
         }
@@ -14288,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");
@@ -14302,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) {
@@ -14357,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(
@@ -14429,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()) {
@@ -14451,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;
     }
@@ -14472,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;
@@ -14485,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);
@@ -14536,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() };
@@ -14551,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);
@@ -14567,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(
@@ -14606,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) {
@@ -14723,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());
   }
@@ -14735,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);
@@ -14764,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);
@@ -14812,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);
     }
@@ -14851,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();
@@ -14867,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);
     }
@@ -14901,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);
@@ -14914,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();
@@ -14927,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);
@@ -14940,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",
@@ -14963,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);
@@ -14977,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",
@@ -14993,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",
@@ -15013,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) {
@@ -15036,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) {
@@ -15063,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);
     }
@@ -15118,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);
@@ -15130,237 +15755,72 @@ var Client = class extends BaseClient {
     return result.getValue();
   }
   /**
-   * Run a node with inputs
+   * Run a node with inputs for testing purposes
    * @param {RunNodeWithInputsRequest} params - The parameters for running the node
-   * @param {string} params.nodeType - The type of the node
+   * @param {string} params.nodeType - The type of the node (restApi, customCode, etc.)
    * @param {Record<string, any>} params.nodeConfig - The configuration for the node
-   * @param {Record<string, any>} params.inputVariables - The input variables for the node
-   * @param {string} params.walletAddress - The wallet address to use for the node
+   * @param {Record<string, any>} params.inputVariables - Variables to pass to the node
    * @param {RequestOptions} options - Request options
    * @returns {Promise<RunNodeWithInputsResponse>} - The response from running the node
    */
   async runNodeWithInputs({ nodeType, nodeConfig, inputVariables = {} }, options) {
-    try {
-      if (nodeType === "blockTrigger" && inputVariables && Object.keys(inputVariables).length > 0) {
-        const variableNames = Object.keys(inputVariables).join(", ");
-        return {
-          success: false,
-          error: `blockTrigger nodes do not accept input variables. Received: ${variableNames}`,
-          nodeId: ""
-        };
-      }
-      const request = new avs_pb22.RunNodeWithInputsReq();
-      let protobufNodeType;
-      switch (nodeType) {
-        // Trigger types - map to CUSTOM_CODE since they're handled specially by the backend
-        case "blockTrigger":
-        case "fixedTimeTrigger":
-        case "cronTrigger":
-        case "eventTrigger":
-        case "manualTrigger":
-          protobufNodeType = avs_pb22.NodeType.NODE_TYPE_CUSTOM_CODE;
-          break;
-        // Regular node types
-        default:
-          protobufNodeType = import_types20.NodeTypeGoConverter.fromGoString(nodeType);
-          break;
-      }
-      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;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.BLOCK_TRIGGER:
-            data = result.getBlockTrigger()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.FIXED_TIME_TRIGGER:
-            data = result.getFixedTimeTrigger()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.CRON_TRIGGER:
-            data = result.getCronTrigger()?.toObject();
-            break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.EVENT_TRIGGER:
-            data = result.getEventTrigger()?.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"
-      };
-    }
-  }
-  createNodeFromConfig(nodeType, config, nodeId) {
-    const nodeProps = {
-      id: nodeId,
-      name: `${nodeType}_node`,
-      type: nodeType,
-      data: this.createNodeData(nodeType, config)
-    };
-    return factory_default2.create(nodeProps);
-  }
-  mapNodeTypeString(nodeType) {
-    const typeMap = {
-      blockTrigger: import_types20.NodeType.CustomCode,
-      // Handle blockTrigger as special CustomCode case
-      restApi: import_types20.NodeType.RestAPI,
-      contractRead: import_types20.NodeType.ContractRead,
-      contractWrite: import_types20.NodeType.ContractWrite,
-      customCode: import_types20.NodeType.CustomCode,
-      ethTransfer: import_types20.NodeType.ETHTransfer,
-      graphqlQuery: import_types20.NodeType.GraphQLQuery,
-      branch: import_types20.NodeType.Branch,
-      filter: import_types20.NodeType.Filter,
-      loop: import_types20.NodeType.Loop
-    };
-    return typeMap[nodeType] || null;
-  }
-  createNodeData(nodeType, config) {
-    switch (nodeType) {
-      case "blockTrigger":
-        return {
-          config: {
-            lang: 0,
-            // JavaScript
-            source: "return { blockNumber: Math.floor(Math.random() * 10000000) };"
-            // Simulate block trigger
-          }
-        };
-      case "restApi":
-        return {
-          config: {
-            url: config.url || "",
-            method: config.method || "GET",
-            body: config.body || "",
-            headersMap: Object.entries(config.headers || {})
-          }
-        };
-      case "contractRead":
-        return {
-          config: {
-            contractAddress: config.contractAddress || "",
-            callData: config.callData || "",
-            contractAbi: config.contractAbi || ""
-          }
-        };
-      case "customCode":
-        return {
-          config: {
-            lang: config.lang || 0,
-            // JavaScript
-            source: config.source || 'return { message: "Node executed successfully" };'
-          }
-        };
-      case "loop":
-        return {
-          config: {
-            sourceId: config.sourceId || "",
-            iterVal: config.iterVal || "",
-            iterKey: config.iterKey || ""
-          }
-        };
-      case "branch":
-        return {
-          config: {
-            conditionsList: config.conditions || []
-          }
-        };
-      case "filter":
-        return {
-          config: {
-            expression: config.expression || "",
-            sourceId: config.sourceId || config.input || ""
-          }
-        };
-      default:
-        throw new Error(`Unsupported node type: ${nodeType}`);
-    }
-  }
-  createTempWorkflowForNode(node, triggerId, inputVariables) {
-    if (node.type === import_types20.NodeType.CustomCode && inputVariables && Object.keys(inputVariables).length > 0) {
-      const customCodeData = node.data;
-      if (customCodeData.config) {
-        const variableDefinitions = Object.entries(inputVariables).map(([key, value]) => {
-          const valueStr = typeof value === "string" ? `"${value}"` : JSON.stringify(value);
-          return `const ${key} = ${valueStr};`;
-        }).join("\n");
-        customCodeData.config.source = `${variableDefinitions}
-${customCodeData.config.source}`;
-      }
-    }
-    const trigger = factory_default.create({
-      id: triggerId,
-      name: "manual_trigger",
-      type: import_types20.TriggerType.Manual,
-      data: inputVariables
-      // Store input variables in the trigger data
-    });
-    return new workflow_default({
-      smartWalletAddress: "",
-      trigger,
-      nodes: [node],
-      edges: [
-        new edge_default({
-          id: `edge_${Date.now()}`,
-          source: triggerId,
-          target: node.id
-        })
-      ],
-      startAt: Date.now(),
-      expiredAt: Date.now() + 36e5,
-      // 1 hour from now
-      maxExecution: 1
-    });
+        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()
+    };
   }
-  extractNodeExecutionData(execution) {
+  /**
+   * Run a trigger for testing purposes
+   * @param {RunTriggerRequest} params - The parameters for running the trigger
+   * @param {string} params.triggerType - The type of the trigger (blockTrigger, cronTrigger, etc.)
+   * @param {Record<string, any>} params.triggerConfig - The configuration for the trigger
+   * @param {RequestOptions} options - Request options
+   * @returns {Promise<RunTriggerResponse>} - The response from running the trigger
+   */
+  async runTrigger({ triggerType, triggerConfig }, options) {
+    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 {
-      executionId: execution.executionId,
-      status: execution.status
+      success: result.getSuccess(),
+      data: factory_default.fromOutputData(result),
+      error: result.getError(),
+      triggerId: result.getTriggerId()
     };
   }
 };