@avaprotocol/sdk-js 1.6.5 → 1.6.6

package/dist/index.mjs

@@ -147,6 +147,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);
@@ -763,6 +766,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);
     };
@@ -10964,7 +10981,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 +10992,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 +11017,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 +11103,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 +11210,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,65 +11373,337 @@ var require_avs_pb = __commonJS({
     proto.aggregator.RunNodeWithInputsResp.prototype.hasLoop = function() {
       return jspb.Message.getField(this, 18) != null;
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.getBlockTrigger = function() {
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.RunTriggerReq.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.RunTriggerReq.toObject(opt_includeInstance, this);
+      };
+      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.RunTriggerReq.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.RunTriggerReq();
+      return proto.aggregator.RunTriggerReq.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.RunTriggerReq.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          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]];
+    proto.aggregator.RunTriggerResp.OutputDataCase = {
+      OUTPUT_DATA_NOT_SET: 0,
+      BLOCK_TRIGGER: 10,
+      FIXED_TIME_TRIGGER: 11,
+      CRON_TRIGGER: 12,
+      EVENT_TRIGGER: 13
+    };
+    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)
+        };
+        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;
+          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
+        );
+      }
+    };
+    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, 20)
+        jspb.Message.getWrapperField(this, proto.aggregator.BlockTrigger.Output, 10)
       );
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.setBlockTrigger = function(value) {
-      return jspb.Message.setOneofWrapperField(this, 20, proto.aggregator.RunNodeWithInputsResp.oneofGroups_[0], value);
+    proto.aggregator.RunTriggerResp.prototype.setBlockTrigger = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 10, proto.aggregator.RunTriggerResp.oneofGroups_[0], value);
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.clearBlockTrigger = function() {
+    proto.aggregator.RunTriggerResp.prototype.clearBlockTrigger = function() {
       return this.setBlockTrigger(void 0);
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.hasBlockTrigger = function() {
-      return jspb.Message.getField(this, 20) != null;
+    proto.aggregator.RunTriggerResp.prototype.hasBlockTrigger = function() {
+      return jspb.Message.getField(this, 10) != null;
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.getFixedTimeTrigger = function() {
+    proto.aggregator.RunTriggerResp.prototype.getFixedTimeTrigger = function() {
       return (
         /** @type{?proto.aggregator.FixedTimeTrigger.Output} */
-        jspb.Message.getWrapperField(this, proto.aggregator.FixedTimeTrigger.Output, 21)
+        jspb.Message.getWrapperField(this, proto.aggregator.FixedTimeTrigger.Output, 11)
       );
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.setFixedTimeTrigger = function(value) {
-      return jspb.Message.setOneofWrapperField(this, 21, proto.aggregator.RunNodeWithInputsResp.oneofGroups_[0], value);
+    proto.aggregator.RunTriggerResp.prototype.setFixedTimeTrigger = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 11, proto.aggregator.RunTriggerResp.oneofGroups_[0], value);
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.clearFixedTimeTrigger = function() {
+    proto.aggregator.RunTriggerResp.prototype.clearFixedTimeTrigger = function() {
       return this.setFixedTimeTrigger(void 0);
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.hasFixedTimeTrigger = function() {
-      return jspb.Message.getField(this, 21) != null;
+    proto.aggregator.RunTriggerResp.prototype.hasFixedTimeTrigger = function() {
+      return jspb.Message.getField(this, 11) != null;
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.getCronTrigger = function() {
+    proto.aggregator.RunTriggerResp.prototype.getCronTrigger = function() {
       return (
         /** @type{?proto.aggregator.CronTrigger.Output} */
-        jspb.Message.getWrapperField(this, proto.aggregator.CronTrigger.Output, 22)
+        jspb.Message.getWrapperField(this, proto.aggregator.CronTrigger.Output, 12)
       );
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.setCronTrigger = function(value) {
-      return jspb.Message.setOneofWrapperField(this, 22, proto.aggregator.RunNodeWithInputsResp.oneofGroups_[0], value);
+    proto.aggregator.RunTriggerResp.prototype.setCronTrigger = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 12, proto.aggregator.RunTriggerResp.oneofGroups_[0], value);
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.clearCronTrigger = function() {
+    proto.aggregator.RunTriggerResp.prototype.clearCronTrigger = function() {
       return this.setCronTrigger(void 0);
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.hasCronTrigger = function() {
-      return jspb.Message.getField(this, 22) != null;
+    proto.aggregator.RunTriggerResp.prototype.hasCronTrigger = function() {
+      return jspb.Message.getField(this, 12) != null;
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.getEventTrigger = function() {
+    proto.aggregator.RunTriggerResp.prototype.getEventTrigger = function() {
       return (
         /** @type{?proto.aggregator.EventTrigger.Output} */
-        jspb.Message.getWrapperField(this, proto.aggregator.EventTrigger.Output, 23)
+        jspb.Message.getWrapperField(this, proto.aggregator.EventTrigger.Output, 13)
       );
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.setEventTrigger = function(value) {
-      return jspb.Message.setOneofWrapperField(this, 23, proto.aggregator.RunNodeWithInputsResp.oneofGroups_[0], value);
+    proto.aggregator.RunTriggerResp.prototype.setEventTrigger = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 13, proto.aggregator.RunTriggerResp.oneofGroups_[0], value);
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.clearEventTrigger = function() {
+    proto.aggregator.RunTriggerResp.prototype.clearEventTrigger = function() {
       return this.setEventTrigger(void 0);
     };
-    proto.aggregator.RunNodeWithInputsResp.prototype.hasEventTrigger = function() {
-      return jspb.Message.getField(this, 23) != null;
+    proto.aggregator.RunTriggerResp.prototype.hasEventTrigger = function() {
+      return jspb.Message.getField(this, 13) != null;
     };
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.Evm.prototype.toObject = function(opt_includeInstance) {
@@ -12908,6 +13137,24 @@ var require_avs_grpc_pb = __commonJS({
     function deserialize_aggregator_RunNodeWithInputsResp(buffer_arg) {
       return avs_pb23.RunNodeWithInputsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
+    function serialize_aggregator_RunTriggerReq(arg) {
+      if (!(arg instanceof avs_pb23.RunTriggerReq)) {
+        throw new Error("Expected argument of type aggregator.RunTriggerReq");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
+    function deserialize_aggregator_RunTriggerReq(buffer_arg) {
+      return avs_pb23.RunTriggerReq.deserializeBinary(new Uint8Array(buffer_arg));
+    }
+    function serialize_aggregator_RunTriggerResp(arg) {
+      if (!(arg instanceof avs_pb23.RunTriggerResp)) {
+        throw new Error("Expected argument of type aggregator.RunTriggerResp");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
+    function deserialize_aggregator_RunTriggerResp(buffer_arg) {
+      return avs_pb23.RunTriggerResp.deserializeBinary(new Uint8Array(buffer_arg));
+    }
     function serialize_aggregator_SetWalletReq(arg) {
       if (!(arg instanceof avs_pb23.SetWalletReq)) {
         throw new Error("Expected argument of type aggregator.SetWalletReq");
@@ -13231,6 +13478,18 @@ var require_avs_grpc_pb = __commonJS({
         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_pb23.RunTriggerReq,
+        responseType: avs_pb23.RunTriggerResp,
+        requestSerialize: serialize_aggregator_RunTriggerReq,
+        requestDeserialize: deserialize_aggregator_RunTriggerReq,
+        responseSerialize: serialize_aggregator_RunTriggerResp,
+        responseDeserialize: deserialize_aggregator_RunTriggerResp
       }
     };
     exports.AggregatorClient = grpc.makeGenericClientConstructor(AggregatorService, "Aggregator");
@@ -14475,7 +14734,11 @@ var Secret = class {
 var secret_default = Secret;
 
 // src/index.ts
-import { NodeType as NodeType13, TriggerType as TriggerType9, NodeTypeGoConverter as NodeTypeGoConverter2 } from "@avaprotocol/types";
+import {
+  TriggerType as TriggerType9,
+  NodeTypeGoConverter as NodeTypeGoConverter2,
+  TriggerTypeGoConverter
+} from "@avaprotocol/types";
 import { AUTH_KEY_HEADER, DEFAULT_LIMIT } from "@avaprotocol/types";
 var BaseClient = class {
   constructor(opts) {
@@ -15103,41 +15366,32 @@ 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(", ");
+      const triggerTypes = [
+        TriggerType9.Block,
+        TriggerType9.FixedTime,
+        TriggerType9.Cron,
+        TriggerType9.Event,
+        TriggerType9.Manual
+      ];
+      if (triggerTypes.includes(nodeType)) {
         return {
           success: false,
-          error: `blockTrigger nodes do not accept input variables. Received: ${variableNames}`,
+          error: `Trigger type "${nodeType}" should use the runTrigger() method instead of runNodeWithInputs()`,
           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 = NodeTypeGoConverter2.fromGoString(nodeType);
-          break;
-      }
+      const protobufNodeType = NodeTypeGoConverter2.fromGoString(nodeType);
       request.setNodeType(protobufNodeType);
       const nodeConfigMap = request.getNodeConfigMap();
       for (const [key, value] of Object.entries(nodeConfig)) {
@@ -15181,16 +15435,53 @@ var Client = class extends BaseClient {
           case avs_pb22.RunNodeWithInputsResp.OutputDataCase.LOOP:
             data = result.getLoop()?.toObject();
             break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.BLOCK_TRIGGER:
+        }
+      }
+      return {
+        success: result.getSuccess(),
+        data,
+        error: result.getError(),
+        nodeId: result.getNodeId()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message || "An error occurred"
+      };
+    }
+  }
+  /**
+   * 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) {
+    try {
+      const request = new avs_pb22.RunTriggerReq();
+      const protobufTriggerType = TriggerTypeGoConverter.fromGoString(triggerType);
+      request.setTriggerType(protobufTriggerType);
+      const triggerConfigMap = request.getTriggerConfigMap();
+      for (const [key, value] of Object.entries(triggerConfig)) {
+        triggerConfigMap.set(key, this.convertJSValueToProtobuf(value));
+      }
+      const result = await this.sendGrpcRequest("runTrigger", request, options);
+      let data;
+      const outputCase = result.getOutputDataCase();
+      if (outputCase !== avs_pb22.RunTriggerResp.OutputDataCase.OUTPUT_DATA_NOT_SET) {
+        switch (outputCase) {
+          case avs_pb22.RunTriggerResp.OutputDataCase.BLOCK_TRIGGER:
             data = result.getBlockTrigger()?.toObject();
             break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.FIXED_TIME_TRIGGER:
+          case avs_pb22.RunTriggerResp.OutputDataCase.FIXED_TIME_TRIGGER:
             data = result.getFixedTimeTrigger()?.toObject();
             break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.CRON_TRIGGER:
+          case avs_pb22.RunTriggerResp.OutputDataCase.CRON_TRIGGER:
             data = result.getCronTrigger()?.toObject();
             break;
-          case avs_pb22.RunNodeWithInputsResp.OutputDataCase.EVENT_TRIGGER:
+          case avs_pb22.RunTriggerResp.OutputDataCase.EVENT_TRIGGER:
             data = result.getEventTrigger()?.toObject();
             break;
         }
@@ -15199,7 +15490,7 @@ var Client = class extends BaseClient {
         success: result.getSuccess(),
         data,
         error: result.getError(),
-        nodeId: result.getNodeId()
+        triggerId: result.getTriggerId()
       };
     } catch (error) {
       return {
@@ -15208,134 +15499,6 @@ var Client = class extends BaseClient {
       };
     }
   }
-  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: NodeType13.CustomCode,
-      // Handle blockTrigger as special CustomCode case
-      restApi: NodeType13.RestAPI,
-      contractRead: NodeType13.ContractRead,
-      contractWrite: NodeType13.ContractWrite,
-      customCode: NodeType13.CustomCode,
-      ethTransfer: NodeType13.ETHTransfer,
-      graphqlQuery: NodeType13.GraphQLQuery,
-      branch: NodeType13.Branch,
-      filter: NodeType13.Filter,
-      loop: NodeType13.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 === NodeType13.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: TriggerType9.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
-    });
-  }
-  extractNodeExecutionData(execution) {
-    return {
-      executionId: execution.executionId,
-      status: execution.status
-    };
-  }
 };
 export {
   block_default as BlockTrigger,