@avaprotocol/sdk-js 1.3.6 → 1.3.8

package/dist/index.js

@@ -72,7 +72,12 @@ var require_avs_pb = __commonJS({
     goog.exportSymbol("proto.aggregator.EventCondition", null, global);
     goog.exportSymbol("proto.aggregator.EventCondition.Matcher", null, global);
     goog.exportSymbol("proto.aggregator.Execution", null, global);
+    goog.exportSymbol("proto.aggregator.Execution.BlockOutput", null, global);
+    goog.exportSymbol("proto.aggregator.Execution.EvmLogOutput", null, global);
+    goog.exportSymbol("proto.aggregator.Execution.OutputDataCase", null, global);
     goog.exportSymbol("proto.aggregator.Execution.Step", null, global);
+    goog.exportSymbol("proto.aggregator.Execution.TimeOutput", null, global);
+    goog.exportSymbol("proto.aggregator.Execution.TransferLogOutput", null, global);
     goog.exportSymbol("proto.aggregator.ExecutionReq", null, global);
     goog.exportSymbol("proto.aggregator.ExecutionStatus", null, global);
     goog.exportSymbol("proto.aggregator.ExecutionStatusResp", null, global);
@@ -107,8 +112,8 @@ var require_avs_pb = __commonJS({
     goog.exportSymbol("proto.aggregator.TaskStatus", null, global);
     goog.exportSymbol("proto.aggregator.TaskTrigger", null, global);
     goog.exportSymbol("proto.aggregator.TaskTrigger.TriggerTypeCase", null, global);
-    goog.exportSymbol("proto.aggregator.TriggerMetadata", null, global);
-    goog.exportSymbol("proto.aggregator.TriggerMetadata.TriggerType", null, global);
+    goog.exportSymbol("proto.aggregator.TriggerReason", null, global);
+    goog.exportSymbol("proto.aggregator.TriggerReason.TriggerType", null, global);
     goog.exportSymbol("proto.aggregator.UserTriggerTaskReq", null, global);
     goog.exportSymbol("proto.aggregator.UserTriggerTaskResp", null, global);
     proto.aggregator.IdReq = function(opt_data) {
@@ -245,19 +250,47 @@ var require_avs_pb = __commonJS({
       proto.aggregator.TaskNode.displayName = "proto.aggregator.TaskNode";
     }
     proto.aggregator.Execution = function(opt_data) {
-      jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.Execution.repeatedFields_, null);
+      jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.Execution.repeatedFields_, proto.aggregator.Execution.oneofGroups_);
     };
     goog.inherits(proto.aggregator.Execution, jspb.Message);
     if (goog.DEBUG && !COMPILED) {
       proto.aggregator.Execution.displayName = "proto.aggregator.Execution";
     }
     proto.aggregator.Execution.Step = function(opt_data) {
-      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+      jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.Execution.Step.repeatedFields_, null);
     };
     goog.inherits(proto.aggregator.Execution.Step, jspb.Message);
     if (goog.DEBUG && !COMPILED) {
       proto.aggregator.Execution.Step.displayName = "proto.aggregator.Execution.Step";
     }
+    proto.aggregator.Execution.TransferLogOutput = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.Execution.TransferLogOutput, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.Execution.TransferLogOutput.displayName = "proto.aggregator.Execution.TransferLogOutput";
+    }
+    proto.aggregator.Execution.EvmLogOutput = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.Execution.EvmLogOutput.repeatedFields_, null);
+    };
+    goog.inherits(proto.aggregator.Execution.EvmLogOutput, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.Execution.EvmLogOutput.displayName = "proto.aggregator.Execution.EvmLogOutput";
+    }
+    proto.aggregator.Execution.BlockOutput = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.Execution.BlockOutput, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.Execution.BlockOutput.displayName = "proto.aggregator.Execution.BlockOutput";
+    }
+    proto.aggregator.Execution.TimeOutput = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.Execution.TimeOutput, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.Execution.TimeOutput.displayName = "proto.aggregator.Execution.TimeOutput";
+    }
     proto.aggregator.Task = function(opt_data) {
       jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.Task.repeatedFields_, null);
     };
@@ -377,12 +410,12 @@ var require_avs_pb = __commonJS({
     if (goog.DEBUG && !COMPILED) {
       proto.aggregator.KeyResp.displayName = "proto.aggregator.KeyResp";
     }
-    proto.aggregator.TriggerMetadata = function(opt_data) {
+    proto.aggregator.TriggerReason = function(opt_data) {
       jspb.Message.initialize(this, opt_data, 0, -1, null, null);
     };
-    goog.inherits(proto.aggregator.TriggerMetadata, jspb.Message);
+    goog.inherits(proto.aggregator.TriggerReason, jspb.Message);
     if (goog.DEBUG && !COMPILED) {
-      proto.aggregator.TriggerMetadata.displayName = "proto.aggregator.TriggerMetadata";
+      proto.aggregator.TriggerReason.displayName = "proto.aggregator.TriggerReason";
     }
     proto.aggregator.GetWalletReq = function(opt_data) {
       jspb.Message.initialize(this, opt_data, 0, -1, null, null);
@@ -2871,6 +2904,20 @@ var require_avs_pb = __commonJS({
       return jspb.Message.getField(this, 18) != null;
     };
     proto.aggregator.Execution.repeatedFields_ = [8];
+    proto.aggregator.Execution.oneofGroups_ = [[10, 11, 12, 13]];
+    proto.aggregator.Execution.OutputDataCase = {
+      OUTPUT_DATA_NOT_SET: 0,
+      TRANSFER_LOG: 10,
+      EVM_LOG: 11,
+      BLOCK: 12,
+      TIME: 13
+    };
+    proto.aggregator.Execution.prototype.getOutputDataCase = function() {
+      return (
+        /** @type {proto.aggregator.Execution.OutputDataCase} */
+        jspb.Message.computeOneofCase(this, proto.aggregator.Execution.oneofGroups_[0])
+      );
+    };
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.Execution.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.Execution.toObject(opt_includeInstance, this);
@@ -2882,13 +2929,17 @@ var require_avs_pb = __commonJS({
           endAt: jspb.Message.getFieldWithDefault(msg, 3, 0),
           success: jspb.Message.getBooleanFieldWithDefault(msg, 4, false),
           error: jspb.Message.getFieldWithDefault(msg, 5, ""),
-          triggerMetadata: (f = msg.getTriggerMetadata()) && proto.aggregator.TriggerMetadata.toObject(includeInstance, f),
-          result: jspb.Message.getFieldWithDefault(msg, 7, ""),
+          reason: (f = msg.getReason()) && proto.aggregator.TriggerReason.toObject(includeInstance, f),
           stepsList: jspb.Message.toObjectList(
             msg.getStepsList(),
             proto.aggregator.Execution.Step.toObject,
             includeInstance
-          )
+          ),
+          triggerName: jspb.Message.getFieldWithDefault(msg, 9, ""),
+          transferLog: (f = msg.getTransferLog()) && proto.aggregator.Execution.TransferLogOutput.toObject(includeInstance, f),
+          evmLog: (f = msg.getEvmLog()) && proto.aggregator.Execution.EvmLogOutput.toObject(includeInstance, f),
+          block: (f = msg.getBlock()) && proto.aggregator.Execution.BlockOutput.toObject(includeInstance, f),
+          time: (f = msg.getTime()) && proto.aggregator.Execution.TimeOutput.toObject(includeInstance, f)
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -2944,21 +2995,41 @@ var require_avs_pb = __commonJS({
             msg.setError(value);
             break;
           case 6:
-            var value = new proto.aggregator.TriggerMetadata();
-            reader.readMessage(value, proto.aggregator.TriggerMetadata.deserializeBinaryFromReader);
-            msg.setTriggerMetadata(value);
+            var value = new proto.aggregator.TriggerReason();
+            reader.readMessage(value, proto.aggregator.TriggerReason.deserializeBinaryFromReader);
+            msg.setReason(value);
             break;
-          case 7:
+          case 8:
+            var value = new proto.aggregator.Execution.Step();
+            reader.readMessage(value, proto.aggregator.Execution.Step.deserializeBinaryFromReader);
+            msg.addSteps(value);
+            break;
+          case 9:
             var value = (
               /** @type {string} */
               reader.readString()
             );
-            msg.setResult(value);
+            msg.setTriggerName(value);
             break;
-          case 8:
-            var value = new proto.aggregator.Execution.Step();
-            reader.readMessage(value, proto.aggregator.Execution.Step.deserializeBinaryFromReader);
-            msg.addSteps(value);
+          case 10:
+            var value = new proto.aggregator.Execution.TransferLogOutput();
+            reader.readMessage(value, proto.aggregator.Execution.TransferLogOutput.deserializeBinaryFromReader);
+            msg.setTransferLog(value);
+            break;
+          case 11:
+            var value = new proto.aggregator.Execution.EvmLogOutput();
+            reader.readMessage(value, proto.aggregator.Execution.EvmLogOutput.deserializeBinaryFromReader);
+            msg.setEvmLog(value);
+            break;
+          case 12:
+            var value = new proto.aggregator.Execution.BlockOutput();
+            reader.readMessage(value, proto.aggregator.Execution.BlockOutput.deserializeBinaryFromReader);
+            msg.setBlock(value);
+            break;
+          case 13:
+            var value = new proto.aggregator.Execution.TimeOutput();
+            reader.readMessage(value, proto.aggregator.Execution.TimeOutput.deserializeBinaryFromReader);
+            msg.setTime(value);
             break;
           default:
             reader.skipField();
@@ -3009,19 +3080,12 @@ var require_avs_pb = __commonJS({
           f
         );
       }
-      f = message.getTriggerMetadata();
+      f = message.getReason();
       if (f != null) {
         writer.writeMessage(
           6,
           f,
-          proto.aggregator.TriggerMetadata.serializeBinaryToWriter
-        );
-      }
-      f = message.getResult();
-      if (f.length > 0) {
-        writer.writeString(
-          7,
-          f
+          proto.aggregator.TriggerReason.serializeBinaryToWriter
         );
       }
       f = message.getStepsList();
@@ -3032,7 +3096,47 @@ var require_avs_pb = __commonJS({
           proto.aggregator.Execution.Step.serializeBinaryToWriter
         );
       }
+      f = message.getTriggerName();
+      if (f.length > 0) {
+        writer.writeString(
+          9,
+          f
+        );
+      }
+      f = message.getTransferLog();
+      if (f != null) {
+        writer.writeMessage(
+          10,
+          f,
+          proto.aggregator.Execution.TransferLogOutput.serializeBinaryToWriter
+        );
+      }
+      f = message.getEvmLog();
+      if (f != null) {
+        writer.writeMessage(
+          11,
+          f,
+          proto.aggregator.Execution.EvmLogOutput.serializeBinaryToWriter
+        );
+      }
+      f = message.getBlock();
+      if (f != null) {
+        writer.writeMessage(
+          12,
+          f,
+          proto.aggregator.Execution.BlockOutput.serializeBinaryToWriter
+        );
+      }
+      f = message.getTime();
+      if (f != null) {
+        writer.writeMessage(
+          13,
+          f,
+          proto.aggregator.Execution.TimeOutput.serializeBinaryToWriter
+        );
+      }
     };
+    proto.aggregator.Execution.Step.repeatedFields_ = [8];
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.Execution.Step.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.Execution.Step.toObject(opt_includeInstance, this);
@@ -3045,7 +3149,8 @@ var require_avs_pb = __commonJS({
           log: jspb.Message.getFieldWithDefault(msg, 4, ""),
           error: jspb.Message.getFieldWithDefault(msg, 5, ""),
           startAt: jspb.Message.getFieldWithDefault(msg, 6, 0),
-          endAt: jspb.Message.getFieldWithDefault(msg, 7, 0)
+          endAt: jspb.Message.getFieldWithDefault(msg, 7, 0),
+          inputsList: (f = jspb.Message.getRepeatedField(msg, 8)) == null ? void 0 : f
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -3105,14 +3210,588 @@ var require_avs_pb = __commonJS({
               /** @type {number} */
               reader.readInt64()
             );
-            msg.setStartAt(value);
+            msg.setStartAt(value);
+            break;
+          case 7:
+            var value = (
+              /** @type {number} */
+              reader.readInt64()
+            );
+            msg.setEndAt(value);
+            break;
+          case 8:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.addInputs(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.Execution.Step.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.Execution.Step.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.Execution.Step.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getNodeId();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
+      }
+      f = message.getSuccess();
+      if (f) {
+        writer.writeBool(
+          2,
+          f
+        );
+      }
+      f = message.getOutputData();
+      if (f.length > 0) {
+        writer.writeString(
+          3,
+          f
+        );
+      }
+      f = message.getLog();
+      if (f.length > 0) {
+        writer.writeString(
+          4,
+          f
+        );
+      }
+      f = message.getError();
+      if (f.length > 0) {
+        writer.writeString(
+          5,
+          f
+        );
+      }
+      f = message.getStartAt();
+      if (f !== 0) {
+        writer.writeInt64(
+          6,
+          f
+        );
+      }
+      f = message.getEndAt();
+      if (f !== 0) {
+        writer.writeInt64(
+          7,
+          f
+        );
+      }
+      f = message.getInputsList();
+      if (f.length > 0) {
+        writer.writeRepeatedString(
+          8,
+          f
+        );
+      }
+    };
+    proto.aggregator.Execution.Step.prototype.getNodeId = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.Execution.Step.prototype.setNodeId = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    proto.aggregator.Execution.Step.prototype.getSuccess = function() {
+      return (
+        /** @type {boolean} */
+        jspb.Message.getBooleanFieldWithDefault(this, 2, false)
+      );
+    };
+    proto.aggregator.Execution.Step.prototype.setSuccess = function(value) {
+      return jspb.Message.setProto3BooleanField(this, 2, value);
+    };
+    proto.aggregator.Execution.Step.prototype.getOutputData = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 3, "")
+      );
+    };
+    proto.aggregator.Execution.Step.prototype.setOutputData = function(value) {
+      return jspb.Message.setProto3StringField(this, 3, value);
+    };
+    proto.aggregator.Execution.Step.prototype.getLog = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 4, "")
+      );
+    };
+    proto.aggregator.Execution.Step.prototype.setLog = function(value) {
+      return jspb.Message.setProto3StringField(this, 4, value);
+    };
+    proto.aggregator.Execution.Step.prototype.getError = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 5, "")
+      );
+    };
+    proto.aggregator.Execution.Step.prototype.setError = function(value) {
+      return jspb.Message.setProto3StringField(this, 5, value);
+    };
+    proto.aggregator.Execution.Step.prototype.getStartAt = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 6, 0)
+      );
+    };
+    proto.aggregator.Execution.Step.prototype.setStartAt = function(value) {
+      return jspb.Message.setProto3IntField(this, 6, value);
+    };
+    proto.aggregator.Execution.Step.prototype.getEndAt = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 7, 0)
+      );
+    };
+    proto.aggregator.Execution.Step.prototype.setEndAt = function(value) {
+      return jspb.Message.setProto3IntField(this, 7, value);
+    };
+    proto.aggregator.Execution.Step.prototype.getInputsList = function() {
+      return (
+        /** @type {!Array<string>} */
+        jspb.Message.getRepeatedField(this, 8)
+      );
+    };
+    proto.aggregator.Execution.Step.prototype.setInputsList = function(value) {
+      return jspb.Message.setField(this, 8, value || []);
+    };
+    proto.aggregator.Execution.Step.prototype.addInputs = function(value, opt_index) {
+      return jspb.Message.addToRepeatedField(this, 8, value, opt_index);
+    };
+    proto.aggregator.Execution.Step.prototype.clearInputsList = function() {
+      return this.setInputsList([]);
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.Execution.TransferLogOutput.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.Execution.TransferLogOutput.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.Execution.TransferLogOutput.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          tokenName: jspb.Message.getFieldWithDefault(msg, 1, ""),
+          tokenSymbol: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          tokenDecimals: jspb.Message.getFieldWithDefault(msg, 3, 0),
+          transactionHash: jspb.Message.getFieldWithDefault(msg, 4, ""),
+          address: jspb.Message.getFieldWithDefault(msg, 5, ""),
+          blockNumber: jspb.Message.getFieldWithDefault(msg, 6, 0),
+          blockTimestamp: jspb.Message.getFieldWithDefault(msg, 7, 0),
+          fromAddress: jspb.Message.getFieldWithDefault(msg, 8, ""),
+          toAddress: jspb.Message.getFieldWithDefault(msg, 9, ""),
+          value: jspb.Message.getFieldWithDefault(msg, 10, ""),
+          valueFormatted: jspb.Message.getFieldWithDefault(msg, 11, ""),
+          transactionIndex: jspb.Message.getFieldWithDefault(msg, 12, 0)
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.Execution.TransferLogOutput.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.Execution.TransferLogOutput();
+      return proto.aggregator.Execution.TransferLogOutput.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.Execution.TransferLogOutput.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setTokenName(value);
+            break;
+          case 2:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setTokenSymbol(value);
+            break;
+          case 3:
+            var value = (
+              /** @type {number} */
+              reader.readUint32()
+            );
+            msg.setTokenDecimals(value);
+            break;
+          case 4:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setTransactionHash(value);
+            break;
+          case 5:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setAddress(value);
+            break;
+          case 6:
+            var value = (
+              /** @type {number} */
+              reader.readUint64()
+            );
+            msg.setBlockNumber(value);
+            break;
+          case 7:
+            var value = (
+              /** @type {number} */
+              reader.readUint64()
+            );
+            msg.setBlockTimestamp(value);
+            break;
+          case 8:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setFromAddress(value);
+            break;
+          case 9:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setToAddress(value);
+            break;
+          case 10:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setValue(value);
+            break;
+          case 11:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setValueFormatted(value);
+            break;
+          case 12:
+            var value = (
+              /** @type {number} */
+              reader.readUint32()
+            );
+            msg.setTransactionIndex(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.Execution.TransferLogOutput.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.Execution.TransferLogOutput.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getTokenName();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
+      }
+      f = message.getTokenSymbol();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
+      }
+      f = message.getTokenDecimals();
+      if (f !== 0) {
+        writer.writeUint32(
+          3,
+          f
+        );
+      }
+      f = message.getTransactionHash();
+      if (f.length > 0) {
+        writer.writeString(
+          4,
+          f
+        );
+      }
+      f = message.getAddress();
+      if (f.length > 0) {
+        writer.writeString(
+          5,
+          f
+        );
+      }
+      f = message.getBlockNumber();
+      if (f !== 0) {
+        writer.writeUint64(
+          6,
+          f
+        );
+      }
+      f = message.getBlockTimestamp();
+      if (f !== 0) {
+        writer.writeUint64(
+          7,
+          f
+        );
+      }
+      f = message.getFromAddress();
+      if (f.length > 0) {
+        writer.writeString(
+          8,
+          f
+        );
+      }
+      f = message.getToAddress();
+      if (f.length > 0) {
+        writer.writeString(
+          9,
+          f
+        );
+      }
+      f = message.getValue();
+      if (f.length > 0) {
+        writer.writeString(
+          10,
+          f
+        );
+      }
+      f = message.getValueFormatted();
+      if (f.length > 0) {
+        writer.writeString(
+          11,
+          f
+        );
+      }
+      f = message.getTransactionIndex();
+      if (f !== 0) {
+        writer.writeUint32(
+          12,
+          f
+        );
+      }
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getTokenName = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setTokenName = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getTokenSymbol = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setTokenSymbol = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getTokenDecimals = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 3, 0)
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setTokenDecimals = function(value) {
+      return jspb.Message.setProto3IntField(this, 3, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getTransactionHash = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 4, "")
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setTransactionHash = function(value) {
+      return jspb.Message.setProto3StringField(this, 4, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getAddress = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 5, "")
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setAddress = function(value) {
+      return jspb.Message.setProto3StringField(this, 5, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getBlockNumber = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 6, 0)
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setBlockNumber = function(value) {
+      return jspb.Message.setProto3IntField(this, 6, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getBlockTimestamp = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 7, 0)
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setBlockTimestamp = function(value) {
+      return jspb.Message.setProto3IntField(this, 7, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getFromAddress = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 8, "")
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setFromAddress = function(value) {
+      return jspb.Message.setProto3StringField(this, 8, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getToAddress = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 9, "")
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setToAddress = function(value) {
+      return jspb.Message.setProto3StringField(this, 9, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getValue = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 10, "")
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setValue = function(value) {
+      return jspb.Message.setProto3StringField(this, 10, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getValueFormatted = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 11, "")
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setValueFormatted = function(value) {
+      return jspb.Message.setProto3StringField(this, 11, value);
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.getTransactionIndex = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 12, 0)
+      );
+    };
+    proto.aggregator.Execution.TransferLogOutput.prototype.setTransactionIndex = function(value) {
+      return jspb.Message.setProto3IntField(this, 12, value);
+    };
+    proto.aggregator.Execution.EvmLogOutput.repeatedFields_ = [6];
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.Execution.EvmLogOutput.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.Execution.EvmLogOutput.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.Execution.EvmLogOutput.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          address: jspb.Message.getFieldWithDefault(msg, 1, ""),
+          blockHash: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          blockNumber: jspb.Message.getFieldWithDefault(msg, 3, 0),
+          data: jspb.Message.getFieldWithDefault(msg, 4, ""),
+          index: jspb.Message.getFieldWithDefault(msg, 5, 0),
+          topicsList: (f = jspb.Message.getRepeatedField(msg, 6)) == null ? void 0 : f,
+          transactionHash: jspb.Message.getFieldWithDefault(msg, 7, ""),
+          transactionIndex: jspb.Message.getFieldWithDefault(msg, 8, 0)
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.Execution.EvmLogOutput.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.Execution.EvmLogOutput();
+      return proto.aggregator.Execution.EvmLogOutput.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.Execution.EvmLogOutput.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setAddress(value);
+            break;
+          case 2:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setBlockHash(value);
+            break;
+          case 3:
+            var value = (
+              /** @type {number} */
+              reader.readUint64()
+            );
+            msg.setBlockNumber(value);
+            break;
+          case 4:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setData(value);
+            break;
+          case 5:
+            var value = (
+              /** @type {number} */
+              reader.readUint32()
+            );
+            msg.setIndex(value);
+            break;
+          case 6:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.addTopics(value);
             break;
           case 7:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setTransactionHash(value);
+            break;
+          case 8:
             var value = (
               /** @type {number} */
-              reader.readInt64()
+              reader.readUint32()
             );
-            msg.setEndAt(value);
+            msg.setTransactionIndex(value);
             break;
           default:
             reader.skipField();
@@ -3121,125 +3800,275 @@ var require_avs_pb = __commonJS({
       }
       return msg;
     };
-    proto.aggregator.Execution.Step.prototype.serializeBinary = function() {
+    proto.aggregator.Execution.EvmLogOutput.prototype.serializeBinary = function() {
       var writer = new jspb.BinaryWriter();
-      proto.aggregator.Execution.Step.serializeBinaryToWriter(this, writer);
+      proto.aggregator.Execution.EvmLogOutput.serializeBinaryToWriter(this, writer);
       return writer.getResultBuffer();
     };
-    proto.aggregator.Execution.Step.serializeBinaryToWriter = function(message, writer) {
+    proto.aggregator.Execution.EvmLogOutput.serializeBinaryToWriter = function(message, writer) {
       var f = void 0;
-      f = message.getNodeId();
+      f = message.getAddress();
       if (f.length > 0) {
         writer.writeString(
           1,
           f
         );
       }
-      f = message.getSuccess();
-      if (f) {
-        writer.writeBool(
+      f = message.getBlockHash();
+      if (f.length > 0) {
+        writer.writeString(
           2,
           f
         );
       }
-      f = message.getOutputData();
-      if (f.length > 0) {
-        writer.writeString(
+      f = message.getBlockNumber();
+      if (f !== 0) {
+        writer.writeUint64(
           3,
           f
         );
       }
-      f = message.getLog();
+      f = message.getData();
       if (f.length > 0) {
         writer.writeString(
           4,
           f
         );
       }
-      f = message.getError();
-      if (f.length > 0) {
-        writer.writeString(
+      f = message.getIndex();
+      if (f !== 0) {
+        writer.writeUint32(
           5,
           f
         );
       }
-      f = message.getStartAt();
-      if (f !== 0) {
-        writer.writeInt64(
+      f = message.getTopicsList();
+      if (f.length > 0) {
+        writer.writeRepeatedString(
           6,
           f
         );
       }
-      f = message.getEndAt();
-      if (f !== 0) {
-        writer.writeInt64(
+      f = message.getTransactionHash();
+      if (f.length > 0) {
+        writer.writeString(
           7,
           f
         );
       }
+      f = message.getTransactionIndex();
+      if (f !== 0) {
+        writer.writeUint32(
+          8,
+          f
+        );
+      }
     };
-    proto.aggregator.Execution.Step.prototype.getNodeId = function() {
+    proto.aggregator.Execution.EvmLogOutput.prototype.getAddress = function() {
       return (
         /** @type {string} */
         jspb.Message.getFieldWithDefault(this, 1, "")
       );
     };
-    proto.aggregator.Execution.Step.prototype.setNodeId = function(value) {
+    proto.aggregator.Execution.EvmLogOutput.prototype.setAddress = function(value) {
       return jspb.Message.setProto3StringField(this, 1, value);
     };
-    proto.aggregator.Execution.Step.prototype.getSuccess = function() {
+    proto.aggregator.Execution.EvmLogOutput.prototype.getBlockHash = function() {
       return (
-        /** @type {boolean} */
-        jspb.Message.getBooleanFieldWithDefault(this, 2, false)
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
       );
     };
-    proto.aggregator.Execution.Step.prototype.setSuccess = function(value) {
-      return jspb.Message.setProto3BooleanField(this, 2, value);
+    proto.aggregator.Execution.EvmLogOutput.prototype.setBlockHash = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
     };
-    proto.aggregator.Execution.Step.prototype.getOutputData = function() {
+    proto.aggregator.Execution.EvmLogOutput.prototype.getBlockNumber = function() {
       return (
-        /** @type {string} */
-        jspb.Message.getFieldWithDefault(this, 3, "")
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 3, 0)
       );
     };
-    proto.aggregator.Execution.Step.prototype.setOutputData = function(value) {
-      return jspb.Message.setProto3StringField(this, 3, value);
+    proto.aggregator.Execution.EvmLogOutput.prototype.setBlockNumber = function(value) {
+      return jspb.Message.setProto3IntField(this, 3, value);
     };
-    proto.aggregator.Execution.Step.prototype.getLog = function() {
+    proto.aggregator.Execution.EvmLogOutput.prototype.getData = function() {
       return (
         /** @type {string} */
         jspb.Message.getFieldWithDefault(this, 4, "")
       );
     };
-    proto.aggregator.Execution.Step.prototype.setLog = function(value) {
+    proto.aggregator.Execution.EvmLogOutput.prototype.setData = function(value) {
       return jspb.Message.setProto3StringField(this, 4, value);
     };
-    proto.aggregator.Execution.Step.prototype.getError = function() {
+    proto.aggregator.Execution.EvmLogOutput.prototype.getIndex = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 5, 0)
+      );
+    };
+    proto.aggregator.Execution.EvmLogOutput.prototype.setIndex = function(value) {
+      return jspb.Message.setProto3IntField(this, 5, value);
+    };
+    proto.aggregator.Execution.EvmLogOutput.prototype.getTopicsList = function() {
+      return (
+        /** @type {!Array<string>} */
+        jspb.Message.getRepeatedField(this, 6)
+      );
+    };
+    proto.aggregator.Execution.EvmLogOutput.prototype.setTopicsList = function(value) {
+      return jspb.Message.setField(this, 6, value || []);
+    };
+    proto.aggregator.Execution.EvmLogOutput.prototype.addTopics = function(value, opt_index) {
+      return jspb.Message.addToRepeatedField(this, 6, value, opt_index);
+    };
+    proto.aggregator.Execution.EvmLogOutput.prototype.clearTopicsList = function() {
+      return this.setTopicsList([]);
+    };
+    proto.aggregator.Execution.EvmLogOutput.prototype.getTransactionHash = function() {
       return (
         /** @type {string} */
-        jspb.Message.getFieldWithDefault(this, 5, "")
+        jspb.Message.getFieldWithDefault(this, 7, "")
       );
     };
-    proto.aggregator.Execution.Step.prototype.setError = function(value) {
-      return jspb.Message.setProto3StringField(this, 5, value);
+    proto.aggregator.Execution.EvmLogOutput.prototype.setTransactionHash = function(value) {
+      return jspb.Message.setProto3StringField(this, 7, value);
     };
-    proto.aggregator.Execution.Step.prototype.getStartAt = function() {
+    proto.aggregator.Execution.EvmLogOutput.prototype.getTransactionIndex = function() {
       return (
         /** @type {number} */
-        jspb.Message.getFieldWithDefault(this, 6, 0)
+        jspb.Message.getFieldWithDefault(this, 8, 0)
       );
     };
-    proto.aggregator.Execution.Step.prototype.setStartAt = function(value) {
-      return jspb.Message.setProto3IntField(this, 6, value);
+    proto.aggregator.Execution.EvmLogOutput.prototype.setTransactionIndex = function(value) {
+      return jspb.Message.setProto3IntField(this, 8, value);
     };
-    proto.aggregator.Execution.Step.prototype.getEndAt = function() {
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.Execution.BlockOutput.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.Execution.BlockOutput.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.Execution.BlockOutput.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          blockNumber: jspb.Message.getFieldWithDefault(msg, 1, 0)
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.Execution.BlockOutput.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.Execution.BlockOutput();
+      return proto.aggregator.Execution.BlockOutput.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.Execution.BlockOutput.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.setBlockNumber(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.Execution.BlockOutput.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.Execution.BlockOutput.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.Execution.BlockOutput.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getBlockNumber();
+      if (f !== 0) {
+        writer.writeUint64(
+          1,
+          f
+        );
+      }
+    };
+    proto.aggregator.Execution.BlockOutput.prototype.getBlockNumber = function() {
       return (
         /** @type {number} */
-        jspb.Message.getFieldWithDefault(this, 7, 0)
+        jspb.Message.getFieldWithDefault(this, 1, 0)
       );
     };
-    proto.aggregator.Execution.Step.prototype.setEndAt = function(value) {
-      return jspb.Message.setProto3IntField(this, 7, value);
+    proto.aggregator.Execution.BlockOutput.prototype.setBlockNumber = function(value) {
+      return jspb.Message.setProto3IntField(this, 1, value);
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.Execution.TimeOutput.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.Execution.TimeOutput.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.Execution.TimeOutput.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          epoch: jspb.Message.getFieldWithDefault(msg, 1, 0)
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.Execution.TimeOutput.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.Execution.TimeOutput();
+      return proto.aggregator.Execution.TimeOutput.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.Execution.TimeOutput.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.setEpoch(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.Execution.TimeOutput.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.Execution.TimeOutput.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.Execution.TimeOutput.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getEpoch();
+      if (f !== 0) {
+        writer.writeUint64(
+          1,
+          f
+        );
+      }
+    };
+    proto.aggregator.Execution.TimeOutput.prototype.getEpoch = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 1, 0)
+      );
+    };
+    proto.aggregator.Execution.TimeOutput.prototype.setEpoch = function(value) {
+      return jspb.Message.setProto3IntField(this, 1, value);
     };
     proto.aggregator.Execution.prototype.getId = function() {
       return (
@@ -3286,30 +4115,21 @@ var require_avs_pb = __commonJS({
     proto.aggregator.Execution.prototype.setError = function(value) {
       return jspb.Message.setProto3StringField(this, 5, value);
     };
-    proto.aggregator.Execution.prototype.getTriggerMetadata = function() {
+    proto.aggregator.Execution.prototype.getReason = function() {
       return (
-        /** @type{?proto.aggregator.TriggerMetadata} */
-        jspb.Message.getWrapperField(this, proto.aggregator.TriggerMetadata, 6)
+        /** @type{?proto.aggregator.TriggerReason} */
+        jspb.Message.getWrapperField(this, proto.aggregator.TriggerReason, 6)
       );
     };
-    proto.aggregator.Execution.prototype.setTriggerMetadata = function(value) {
+    proto.aggregator.Execution.prototype.setReason = function(value) {
       return jspb.Message.setWrapperField(this, 6, value);
     };
-    proto.aggregator.Execution.prototype.clearTriggerMetadata = function() {
-      return this.setTriggerMetadata(void 0);
+    proto.aggregator.Execution.prototype.clearReason = function() {
+      return this.setReason(void 0);
     };
-    proto.aggregator.Execution.prototype.hasTriggerMetadata = function() {
+    proto.aggregator.Execution.prototype.hasReason = function() {
       return jspb.Message.getField(this, 6) != null;
     };
-    proto.aggregator.Execution.prototype.getResult = function() {
-      return (
-        /** @type {string} */
-        jspb.Message.getFieldWithDefault(this, 7, "")
-      );
-    };
-    proto.aggregator.Execution.prototype.setResult = function(value) {
-      return jspb.Message.setProto3StringField(this, 7, value);
-    };
     proto.aggregator.Execution.prototype.getStepsList = function() {
       return (
         /** @type{!Array<!proto.aggregator.Execution.Step>} */
@@ -3325,6 +4145,75 @@ var require_avs_pb = __commonJS({
     proto.aggregator.Execution.prototype.clearStepsList = function() {
       return this.setStepsList([]);
     };
+    proto.aggregator.Execution.prototype.getTriggerName = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 9, "")
+      );
+    };
+    proto.aggregator.Execution.prototype.setTriggerName = function(value) {
+      return jspb.Message.setProto3StringField(this, 9, value);
+    };
+    proto.aggregator.Execution.prototype.getTransferLog = function() {
+      return (
+        /** @type{?proto.aggregator.Execution.TransferLogOutput} */
+        jspb.Message.getWrapperField(this, proto.aggregator.Execution.TransferLogOutput, 10)
+      );
+    };
+    proto.aggregator.Execution.prototype.setTransferLog = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 10, proto.aggregator.Execution.oneofGroups_[0], value);
+    };
+    proto.aggregator.Execution.prototype.clearTransferLog = function() {
+      return this.setTransferLog(void 0);
+    };
+    proto.aggregator.Execution.prototype.hasTransferLog = function() {
+      return jspb.Message.getField(this, 10) != null;
+    };
+    proto.aggregator.Execution.prototype.getEvmLog = function() {
+      return (
+        /** @type{?proto.aggregator.Execution.EvmLogOutput} */
+        jspb.Message.getWrapperField(this, proto.aggregator.Execution.EvmLogOutput, 11)
+      );
+    };
+    proto.aggregator.Execution.prototype.setEvmLog = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 11, proto.aggregator.Execution.oneofGroups_[0], value);
+    };
+    proto.aggregator.Execution.prototype.clearEvmLog = function() {
+      return this.setEvmLog(void 0);
+    };
+    proto.aggregator.Execution.prototype.hasEvmLog = function() {
+      return jspb.Message.getField(this, 11) != null;
+    };
+    proto.aggregator.Execution.prototype.getBlock = function() {
+      return (
+        /** @type{?proto.aggregator.Execution.BlockOutput} */
+        jspb.Message.getWrapperField(this, proto.aggregator.Execution.BlockOutput, 12)
+      );
+    };
+    proto.aggregator.Execution.prototype.setBlock = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 12, proto.aggregator.Execution.oneofGroups_[0], value);
+    };
+    proto.aggregator.Execution.prototype.clearBlock = function() {
+      return this.setBlock(void 0);
+    };
+    proto.aggregator.Execution.prototype.hasBlock = function() {
+      return jspb.Message.getField(this, 12) != null;
+    };
+    proto.aggregator.Execution.prototype.getTime = function() {
+      return (
+        /** @type{?proto.aggregator.Execution.TimeOutput} */
+        jspb.Message.getWrapperField(this, proto.aggregator.Execution.TimeOutput, 13)
+      );
+    };
+    proto.aggregator.Execution.prototype.setTime = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 13, proto.aggregator.Execution.oneofGroups_[0], value);
+    };
+    proto.aggregator.Execution.prototype.clearTime = function() {
+      return this.setTime(void 0);
+    };
+    proto.aggregator.Execution.prototype.hasTime = function() {
+      return jspb.Message.getField(this, 13) != null;
+    };
     proto.aggregator.Task.repeatedFields_ = [13, 14];
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.Task.prototype.toObject = function(opt_includeInstance) {
@@ -5649,10 +6538,10 @@ var require_avs_pb = __commonJS({
       return jspb.Message.setProto3StringField(this, 1, value);
     };
     if (jspb.Message.GENERATE_TO_OBJECT) {
-      proto.aggregator.TriggerMetadata.prototype.toObject = function(opt_includeInstance) {
-        return proto.aggregator.TriggerMetadata.toObject(opt_includeInstance, this);
+      proto.aggregator.TriggerReason.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.TriggerReason.toObject(opt_includeInstance, this);
       };
-      proto.aggregator.TriggerMetadata.toObject = function(includeInstance, msg) {
+      proto.aggregator.TriggerReason.toObject = function(includeInstance, msg) {
         var f, obj = {
           blockNumber: jspb.Message.getFieldWithDefault(msg, 1, 0),
           logIndex: jspb.Message.getFieldWithDefault(msg, 2, 0),
@@ -5666,12 +6555,12 @@ var require_avs_pb = __commonJS({
         return obj;
       };
     }
-    proto.aggregator.TriggerMetadata.deserializeBinary = function(bytes) {
+    proto.aggregator.TriggerReason.deserializeBinary = function(bytes) {
       var reader = new jspb.BinaryReader(bytes);
-      var msg = new proto.aggregator.TriggerMetadata();
-      return proto.aggregator.TriggerMetadata.deserializeBinaryFromReader(msg, reader);
+      var msg = new proto.aggregator.TriggerReason();
+      return proto.aggregator.TriggerReason.deserializeBinaryFromReader(msg, reader);
     };
-    proto.aggregator.TriggerMetadata.deserializeBinaryFromReader = function(msg, reader) {
+    proto.aggregator.TriggerReason.deserializeBinaryFromReader = function(msg, reader) {
       while (reader.nextField()) {
         if (reader.isEndGroup()) {
           break;
@@ -5708,7 +6597,7 @@ var require_avs_pb = __commonJS({
             break;
           case 5:
             var value = (
-              /** @type {!proto.aggregator.TriggerMetadata.TriggerType} */
+              /** @type {!proto.aggregator.TriggerReason.TriggerType} */
               reader.readEnum()
             );
             msg.setType(value);
@@ -5720,12 +6609,12 @@ var require_avs_pb = __commonJS({
       }
       return msg;
     };
-    proto.aggregator.TriggerMetadata.prototype.serializeBinary = function() {
+    proto.aggregator.TriggerReason.prototype.serializeBinary = function() {
       var writer = new jspb.BinaryWriter();
-      proto.aggregator.TriggerMetadata.serializeBinaryToWriter(this, writer);
+      proto.aggregator.TriggerReason.serializeBinaryToWriter(this, writer);
       return writer.getResultBuffer();
     };
-    proto.aggregator.TriggerMetadata.serializeBinaryToWriter = function(message, writer) {
+    proto.aggregator.TriggerReason.serializeBinaryToWriter = function(message, writer) {
       var f = void 0;
       f = message.getBlockNumber();
       if (f !== 0) {
@@ -5763,7 +6652,7 @@ var require_avs_pb = __commonJS({
         );
       }
     };
-    proto.aggregator.TriggerMetadata.TriggerType = {
+    proto.aggregator.TriggerReason.TriggerType = {
       UNSET: 0,
       MANUAL: 2,
       FIXEDTIME: 3,
@@ -5771,49 +6660,49 @@ var require_avs_pb = __commonJS({
       BLOCK: 5,
       EVENT: 6
     };
-    proto.aggregator.TriggerMetadata.prototype.getBlockNumber = function() {
+    proto.aggregator.TriggerReason.prototype.getBlockNumber = function() {
       return (
         /** @type {number} */
         jspb.Message.getFieldWithDefault(this, 1, 0)
       );
     };
-    proto.aggregator.TriggerMetadata.prototype.setBlockNumber = function(value) {
+    proto.aggregator.TriggerReason.prototype.setBlockNumber = function(value) {
       return jspb.Message.setProto3IntField(this, 1, value);
     };
-    proto.aggregator.TriggerMetadata.prototype.getLogIndex = function() {
+    proto.aggregator.TriggerReason.prototype.getLogIndex = function() {
       return (
         /** @type {number} */
         jspb.Message.getFieldWithDefault(this, 2, 0)
       );
     };
-    proto.aggregator.TriggerMetadata.prototype.setLogIndex = function(value) {
+    proto.aggregator.TriggerReason.prototype.setLogIndex = function(value) {
       return jspb.Message.setProto3IntField(this, 2, value);
     };
-    proto.aggregator.TriggerMetadata.prototype.getTxHash = function() {
+    proto.aggregator.TriggerReason.prototype.getTxHash = function() {
       return (
         /** @type {string} */
         jspb.Message.getFieldWithDefault(this, 3, "")
       );
     };
-    proto.aggregator.TriggerMetadata.prototype.setTxHash = function(value) {
+    proto.aggregator.TriggerReason.prototype.setTxHash = function(value) {
       return jspb.Message.setProto3StringField(this, 3, value);
     };
-    proto.aggregator.TriggerMetadata.prototype.getEpoch = function() {
+    proto.aggregator.TriggerReason.prototype.getEpoch = function() {
       return (
         /** @type {number} */
         jspb.Message.getFieldWithDefault(this, 4, 0)
       );
     };
-    proto.aggregator.TriggerMetadata.prototype.setEpoch = function(value) {
+    proto.aggregator.TriggerReason.prototype.setEpoch = function(value) {
       return jspb.Message.setProto3IntField(this, 4, value);
     };
-    proto.aggregator.TriggerMetadata.prototype.getType = function() {
+    proto.aggregator.TriggerReason.prototype.getType = function() {
       return (
-        /** @type {!proto.aggregator.TriggerMetadata.TriggerType} */
+        /** @type {!proto.aggregator.TriggerReason.TriggerType} */
         jspb.Message.getFieldWithDefault(this, 5, 0)
       );
     };
-    proto.aggregator.TriggerMetadata.prototype.setType = function(value) {
+    proto.aggregator.TriggerReason.prototype.setType = function(value) {
       return jspb.Message.setProto3EnumField(this, 5, value);
     };
     if (jspb.Message.GENERATE_TO_OBJECT) {
@@ -6143,7 +7032,7 @@ var require_avs_pb = __commonJS({
       proto.aggregator.UserTriggerTaskReq.toObject = function(includeInstance, msg) {
         var f, obj = {
           taskId: jspb.Message.getFieldWithDefault(msg, 1, ""),
-          triggerMetadata: (f = msg.getTriggerMetadata()) && proto.aggregator.TriggerMetadata.toObject(includeInstance, f),
+          reason: (f = msg.getReason()) && proto.aggregator.TriggerReason.toObject(includeInstance, f),
           isBlocking: jspb.Message.getBooleanFieldWithDefault(msg, 3, false)
         };
         if (includeInstance) {
@@ -6172,9 +7061,9 @@ var require_avs_pb = __commonJS({
             msg.setTaskId(value);
             break;
           case 2:
-            var value = new proto.aggregator.TriggerMetadata();
-            reader.readMessage(value, proto.aggregator.TriggerMetadata.deserializeBinaryFromReader);
-            msg.setTriggerMetadata(value);
+            var value = new proto.aggregator.TriggerReason();
+            reader.readMessage(value, proto.aggregator.TriggerReason.deserializeBinaryFromReader);
+            msg.setReason(value);
             break;
           case 3:
             var value = (
@@ -6204,12 +7093,12 @@ var require_avs_pb = __commonJS({
           f
         );
       }
-      f = message.getTriggerMetadata();
+      f = message.getReason();
       if (f != null) {
         writer.writeMessage(
           2,
           f,
-          proto.aggregator.TriggerMetadata.serializeBinaryToWriter
+          proto.aggregator.TriggerReason.serializeBinaryToWriter
         );
       }
       f = message.getIsBlocking();
@@ -6229,19 +7118,19 @@ var require_avs_pb = __commonJS({
     proto.aggregator.UserTriggerTaskReq.prototype.setTaskId = function(value) {
       return jspb.Message.setProto3StringField(this, 1, value);
     };
-    proto.aggregator.UserTriggerTaskReq.prototype.getTriggerMetadata = function() {
+    proto.aggregator.UserTriggerTaskReq.prototype.getReason = function() {
       return (
-        /** @type{?proto.aggregator.TriggerMetadata} */
-        jspb.Message.getWrapperField(this, proto.aggregator.TriggerMetadata, 2)
+        /** @type{?proto.aggregator.TriggerReason} */
+        jspb.Message.getWrapperField(this, proto.aggregator.TriggerReason, 2)
       );
     };
-    proto.aggregator.UserTriggerTaskReq.prototype.setTriggerMetadata = function(value) {
+    proto.aggregator.UserTriggerTaskReq.prototype.setReason = function(value) {
       return jspb.Message.setWrapperField(this, 2, value);
     };
-    proto.aggregator.UserTriggerTaskReq.prototype.clearTriggerMetadata = function() {
-      return this.setTriggerMetadata(void 0);
+    proto.aggregator.UserTriggerTaskReq.prototype.clearReason = function() {
+      return this.setReason(void 0);
     };
-    proto.aggregator.UserTriggerTaskReq.prototype.hasTriggerMetadata = function() {
+    proto.aggregator.UserTriggerTaskReq.prototype.hasReason = function() {
       return jspb.Message.getField(this, 2) != null;
     };
     proto.aggregator.UserTriggerTaskReq.prototype.getIsBlocking = function() {
@@ -6897,233 +7786,233 @@ var require_avs_grpc_pb = __commonJS({
   "../../grpc_codegen/avs_grpc_pb.js"(exports2) {
     "use strict";
     var grpc = require("@grpc/grpc-js");
-    var avs_pb21 = require_avs_pb();
+    var avs_pb22 = require_avs_pb();
     var google_protobuf_wrappers_pb = require("google-protobuf/google/protobuf/wrappers_pb.js");
     var google_protobuf_timestamp_pb = require("google-protobuf/google/protobuf/timestamp_pb.js");
     function serialize_aggregator_CreateOrUpdateSecretReq(arg) {
-      if (!(arg instanceof avs_pb21.CreateOrUpdateSecretReq)) {
+      if (!(arg instanceof avs_pb22.CreateOrUpdateSecretReq)) {
         throw new Error("Expected argument of type aggregator.CreateOrUpdateSecretReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateOrUpdateSecretReq(buffer_arg) {
-      return avs_pb21.CreateOrUpdateSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.CreateOrUpdateSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateTaskReq(arg) {
-      if (!(arg instanceof avs_pb21.CreateTaskReq)) {
+      if (!(arg instanceof avs_pb22.CreateTaskReq)) {
         throw new Error("Expected argument of type aggregator.CreateTaskReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateTaskReq(buffer_arg) {
-      return avs_pb21.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateTaskResp(arg) {
-      if (!(arg instanceof avs_pb21.CreateTaskResp)) {
+      if (!(arg instanceof avs_pb22.CreateTaskResp)) {
         throw new Error("Expected argument of type aggregator.CreateTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateTaskResp(buffer_arg) {
-      return avs_pb21.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_DeleteSecretReq(arg) {
-      if (!(arg instanceof avs_pb21.DeleteSecretReq)) {
+      if (!(arg instanceof avs_pb22.DeleteSecretReq)) {
         throw new Error("Expected argument of type aggregator.DeleteSecretReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_DeleteSecretReq(buffer_arg) {
-      return avs_pb21.DeleteSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.DeleteSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_Execution(arg) {
-      if (!(arg instanceof avs_pb21.Execution)) {
+      if (!(arg instanceof avs_pb22.Execution)) {
         throw new Error("Expected argument of type aggregator.Execution");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_Execution(buffer_arg) {
-      return avs_pb21.Execution.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.Execution.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ExecutionReq(arg) {
-      if (!(arg instanceof avs_pb21.ExecutionReq)) {
+      if (!(arg instanceof avs_pb22.ExecutionReq)) {
         throw new Error("Expected argument of type aggregator.ExecutionReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ExecutionReq(buffer_arg) {
-      return avs_pb21.ExecutionReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ExecutionReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ExecutionStatusResp(arg) {
-      if (!(arg instanceof avs_pb21.ExecutionStatusResp)) {
+      if (!(arg instanceof avs_pb22.ExecutionStatusResp)) {
         throw new Error("Expected argument of type aggregator.ExecutionStatusResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ExecutionStatusResp(buffer_arg) {
-      return avs_pb21.ExecutionStatusResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ExecutionStatusResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetKeyReq(arg) {
-      if (!(arg instanceof avs_pb21.GetKeyReq)) {
+      if (!(arg instanceof avs_pb22.GetKeyReq)) {
         throw new Error("Expected argument of type aggregator.GetKeyReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetKeyReq(buffer_arg) {
-      return avs_pb21.GetKeyReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.GetKeyReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWalletReq(arg) {
-      if (!(arg instanceof avs_pb21.GetWalletReq)) {
+      if (!(arg instanceof avs_pb22.GetWalletReq)) {
         throw new Error("Expected argument of type aggregator.GetWalletReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWalletReq(buffer_arg) {
-      return avs_pb21.GetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.GetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWalletResp(arg) {
-      if (!(arg instanceof avs_pb21.GetWalletResp)) {
+      if (!(arg instanceof avs_pb22.GetWalletResp)) {
         throw new Error("Expected argument of type aggregator.GetWalletResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWalletResp(buffer_arg) {
-      return avs_pb21.GetWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.GetWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_IdReq(arg) {
-      if (!(arg instanceof avs_pb21.IdReq)) {
+      if (!(arg instanceof avs_pb22.IdReq)) {
         throw new Error("Expected argument of type aggregator.IdReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_IdReq(buffer_arg) {
-      return avs_pb21.IdReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.IdReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_KeyResp(arg) {
-      if (!(arg instanceof avs_pb21.KeyResp)) {
+      if (!(arg instanceof avs_pb22.KeyResp)) {
         throw new Error("Expected argument of type aggregator.KeyResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_KeyResp(buffer_arg) {
-      return avs_pb21.KeyResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.KeyResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListExecutionsReq(arg) {
-      if (!(arg instanceof avs_pb21.ListExecutionsReq)) {
+      if (!(arg instanceof avs_pb22.ListExecutionsReq)) {
         throw new Error("Expected argument of type aggregator.ListExecutionsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListExecutionsReq(buffer_arg) {
-      return avs_pb21.ListExecutionsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListExecutionsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListExecutionsResp(arg) {
-      if (!(arg instanceof avs_pb21.ListExecutionsResp)) {
+      if (!(arg instanceof avs_pb22.ListExecutionsResp)) {
         throw new Error("Expected argument of type aggregator.ListExecutionsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListExecutionsResp(buffer_arg) {
-      return avs_pb21.ListExecutionsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListExecutionsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListSecretsReq(arg) {
-      if (!(arg instanceof avs_pb21.ListSecretsReq)) {
+      if (!(arg instanceof avs_pb22.ListSecretsReq)) {
         throw new Error("Expected argument of type aggregator.ListSecretsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListSecretsReq(buffer_arg) {
-      return avs_pb21.ListSecretsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListSecretsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListSecretsResp(arg) {
-      if (!(arg instanceof avs_pb21.ListSecretsResp)) {
+      if (!(arg instanceof avs_pb22.ListSecretsResp)) {
         throw new Error("Expected argument of type aggregator.ListSecretsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListSecretsResp(buffer_arg) {
-      return avs_pb21.ListSecretsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListSecretsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListTasksReq(arg) {
-      if (!(arg instanceof avs_pb21.ListTasksReq)) {
+      if (!(arg instanceof avs_pb22.ListTasksReq)) {
         throw new Error("Expected argument of type aggregator.ListTasksReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListTasksReq(buffer_arg) {
-      return avs_pb21.ListTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListTasksResp(arg) {
-      if (!(arg instanceof avs_pb21.ListTasksResp)) {
+      if (!(arg instanceof avs_pb22.ListTasksResp)) {
         throw new Error("Expected argument of type aggregator.ListTasksResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListTasksResp(buffer_arg) {
-      return avs_pb21.ListTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListWalletReq(arg) {
-      if (!(arg instanceof avs_pb21.ListWalletReq)) {
+      if (!(arg instanceof avs_pb22.ListWalletReq)) {
         throw new Error("Expected argument of type aggregator.ListWalletReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListWalletReq(buffer_arg) {
-      return avs_pb21.ListWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListWalletResp(arg) {
-      if (!(arg instanceof avs_pb21.ListWalletResp)) {
+      if (!(arg instanceof avs_pb22.ListWalletResp)) {
         throw new Error("Expected argument of type aggregator.ListWalletResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListWalletResp(buffer_arg) {
-      return avs_pb21.ListWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.ListWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_NonceRequest(arg) {
-      if (!(arg instanceof avs_pb21.NonceRequest)) {
+      if (!(arg instanceof avs_pb22.NonceRequest)) {
         throw new Error("Expected argument of type aggregator.NonceRequest");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_NonceRequest(buffer_arg) {
-      return avs_pb21.NonceRequest.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.NonceRequest.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_NonceResp(arg) {
-      if (!(arg instanceof avs_pb21.NonceResp)) {
+      if (!(arg instanceof avs_pb22.NonceResp)) {
         throw new Error("Expected argument of type aggregator.NonceResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_NonceResp(buffer_arg) {
-      return avs_pb21.NonceResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.NonceResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_Task(arg) {
-      if (!(arg instanceof avs_pb21.Task)) {
+      if (!(arg instanceof avs_pb22.Task)) {
         throw new Error("Expected argument of type aggregator.Task");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_Task(buffer_arg) {
-      return avs_pb21.Task.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.Task.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_UserTriggerTaskReq(arg) {
-      if (!(arg instanceof avs_pb21.UserTriggerTaskReq)) {
+      if (!(arg instanceof avs_pb22.UserTriggerTaskReq)) {
         throw new Error("Expected argument of type aggregator.UserTriggerTaskReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_UserTriggerTaskReq(buffer_arg) {
-      return avs_pb21.UserTriggerTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.UserTriggerTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_UserTriggerTaskResp(arg) {
-      if (!(arg instanceof avs_pb21.UserTriggerTaskResp)) {
+      if (!(arg instanceof avs_pb22.UserTriggerTaskResp)) {
         throw new Error("Expected argument of type aggregator.UserTriggerTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_UserTriggerTaskResp(buffer_arg) {
-      return avs_pb21.UserTriggerTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb22.UserTriggerTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_google_protobuf_BoolValue(arg) {
       if (!(arg instanceof google_protobuf_wrappers_pb.BoolValue)) {
@@ -7140,8 +8029,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetKey",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.GetKeyReq,
-        responseType: avs_pb21.KeyResp,
+        requestType: avs_pb22.GetKeyReq,
+        responseType: avs_pb22.KeyResp,
         requestSerialize: serialize_aggregator_GetKeyReq,
         requestDeserialize: deserialize_aggregator_GetKeyReq,
         responseSerialize: serialize_aggregator_KeyResp,
@@ -7152,8 +8041,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetNonce",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.NonceRequest,
-        responseType: avs_pb21.NonceResp,
+        requestType: avs_pb22.NonceRequest,
+        responseType: avs_pb22.NonceResp,
         requestSerialize: serialize_aggregator_NonceRequest,
         requestDeserialize: deserialize_aggregator_NonceRequest,
         responseSerialize: serialize_aggregator_NonceResp,
@@ -7163,8 +8052,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetWallet",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.GetWalletReq,
-        responseType: avs_pb21.GetWalletResp,
+        requestType: avs_pb22.GetWalletReq,
+        responseType: avs_pb22.GetWalletResp,
         requestSerialize: serialize_aggregator_GetWalletReq,
         requestDeserialize: deserialize_aggregator_GetWalletReq,
         responseSerialize: serialize_aggregator_GetWalletResp,
@@ -7174,8 +8063,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListWallets",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.ListWalletReq,
-        responseType: avs_pb21.ListWalletResp,
+        requestType: avs_pb22.ListWalletReq,
+        responseType: avs_pb22.ListWalletResp,
         requestSerialize: serialize_aggregator_ListWalletReq,
         requestDeserialize: deserialize_aggregator_ListWalletReq,
         responseSerialize: serialize_aggregator_ListWalletResp,
@@ -7186,8 +8075,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CreateTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.CreateTaskReq,
-        responseType: avs_pb21.CreateTaskResp,
+        requestType: avs_pb22.CreateTaskReq,
+        responseType: avs_pb22.CreateTaskResp,
         requestSerialize: serialize_aggregator_CreateTaskReq,
         requestDeserialize: deserialize_aggregator_CreateTaskReq,
         responseSerialize: serialize_aggregator_CreateTaskResp,
@@ -7197,8 +8086,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListTasks",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.ListTasksReq,
-        responseType: avs_pb21.ListTasksResp,
+        requestType: avs_pb22.ListTasksReq,
+        responseType: avs_pb22.ListTasksResp,
         requestSerialize: serialize_aggregator_ListTasksReq,
         requestDeserialize: deserialize_aggregator_ListTasksReq,
         responseSerialize: serialize_aggregator_ListTasksResp,
@@ -7208,8 +8097,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.IdReq,
-        responseType: avs_pb21.Task,
+        requestType: avs_pb22.IdReq,
+        responseType: avs_pb22.Task,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
         responseSerialize: serialize_aggregator_Task,
@@ -7219,8 +8108,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListExecutions",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.ListExecutionsReq,
-        responseType: avs_pb21.ListExecutionsResp,
+        requestType: avs_pb22.ListExecutionsReq,
+        responseType: avs_pb22.ListExecutionsResp,
         requestSerialize: serialize_aggregator_ListExecutionsReq,
         requestDeserialize: deserialize_aggregator_ListExecutionsReq,
         responseSerialize: serialize_aggregator_ListExecutionsResp,
@@ -7230,8 +8119,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecution",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.ExecutionReq,
-        responseType: avs_pb21.Execution,
+        requestType: avs_pb22.ExecutionReq,
+        responseType: avs_pb22.Execution,
         requestSerialize: serialize_aggregator_ExecutionReq,
         requestDeserialize: deserialize_aggregator_ExecutionReq,
         responseSerialize: serialize_aggregator_Execution,
@@ -7241,8 +8130,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecutionStatus",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.ExecutionReq,
-        responseType: avs_pb21.ExecutionStatusResp,
+        requestType: avs_pb22.ExecutionReq,
+        responseType: avs_pb22.ExecutionStatusResp,
         requestSerialize: serialize_aggregator_ExecutionReq,
         requestDeserialize: deserialize_aggregator_ExecutionReq,
         responseSerialize: serialize_aggregator_ExecutionStatusResp,
@@ -7252,7 +8141,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CancelTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.IdReq,
+        requestType: avs_pb22.IdReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
@@ -7263,7 +8152,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/DeleteTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.IdReq,
+        requestType: avs_pb22.IdReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
@@ -7274,8 +8163,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/TriggerTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.UserTriggerTaskReq,
-        responseType: avs_pb21.UserTriggerTaskResp,
+        requestType: avs_pb22.UserTriggerTaskReq,
+        responseType: avs_pb22.UserTriggerTaskResp,
         requestSerialize: serialize_aggregator_UserTriggerTaskReq,
         requestDeserialize: deserialize_aggregator_UserTriggerTaskReq,
         responseSerialize: serialize_aggregator_UserTriggerTaskResp,
@@ -7288,7 +8177,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CreateSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.CreateOrUpdateSecretReq,
+        requestType: avs_pb22.CreateOrUpdateSecretReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_CreateOrUpdateSecretReq,
         requestDeserialize: deserialize_aggregator_CreateOrUpdateSecretReq,
@@ -7299,7 +8188,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/DeleteSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.DeleteSecretReq,
+        requestType: avs_pb22.DeleteSecretReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_DeleteSecretReq,
         requestDeserialize: deserialize_aggregator_DeleteSecretReq,
@@ -7312,8 +8201,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListSecrets",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.ListSecretsReq,
-        responseType: avs_pb21.ListSecretsResp,
+        requestType: avs_pb22.ListSecretsReq,
+        responseType: avs_pb22.ListSecretsResp,
         requestSerialize: serialize_aggregator_ListSecretsReq,
         requestDeserialize: deserialize_aggregator_ListSecretsReq,
         responseSerialize: serialize_aggregator_ListSecretsResp,
@@ -7325,7 +8214,7 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/UpdateSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb21.CreateOrUpdateSecretReq,
+        requestType: avs_pb22.CreateOrUpdateSecretReq,
         responseType: google_protobuf_wrappers_pb.BoolValue,
         requestSerialize: serialize_aggregator_CreateOrUpdateSecretReq,
         requestDeserialize: deserialize_aggregator_CreateOrUpdateSecretReq,
@@ -7333,7 +8222,7 @@ var require_avs_grpc_pb = __commonJS({
         responseDeserialize: deserialize_google_protobuf_BoolValue
       }
     };
-    exports2.AggregatorClient = grpc.makeGenericClientConstructor(AggregatorService);
+    exports2.AggregatorClient = grpc.makeGenericClientConstructor(AggregatorService, "Aggregator");
   }
 });
 
@@ -7343,6 +8232,7 @@ __export(index_exports, {
   AUTH_KEY_HEADER: () => AUTH_KEY_HEADER,
   BlockTrigger: () => block_default,
   BranchNode: () => branch_default,
+  Client: () => Client,
   ContractReadNode: () => contractRead_default,
   ContractWriteNode: () => contractWrite_default,
   CronTrigger: () => cron_default,
@@ -7360,20 +8250,20 @@ __export(index_exports, {
   Node: () => interface_default2,
   NodeFactory: () => factory_default2,
   RestAPINode: () => restApi_default,
+  Secret: () => secret_default,
   Step: () => step_default,
   Trigger: () => interface_default,
   TriggerFactory: () => factory_default,
-  TriggerMetadata: () => metadata_default,
+  TriggerReason: () => reason_default,
   TriggerType: () => TriggerType,
   Workflow: () => workflow_default,
-  WorkflowStatus: () => WorkflowStatus,
-  default: () => Client
+  WorkflowStatus: () => WorkflowStatus
 });
 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_pb20 = __toESM(require_avs_pb());
+var avs_pb21 = __toESM(require_avs_pb());
 var import_timestamp_pb = require("google-protobuf/google/protobuf/timestamp_pb");
 
 // src/models/workflow.ts
@@ -8078,20 +8968,20 @@ var workflow_default = Workflow;
 // src/models/execution.ts
 var avs_pb19 = __toESM(require_avs_pb());
 
-// src/models/trigger/metadata.ts
+// src/models/trigger/reason.ts
 var avs_pb17 = __toESM(require_avs_pb());
 var convertTriggerType = (grpcType) => {
   const conversionMap = {
-    [avs_pb17.TriggerMetadata.TriggerType.FIXEDTIME]: "fixed_time" /* FixedTime */,
-    [avs_pb17.TriggerMetadata.TriggerType.CRON]: "cron" /* Cron */,
-    [avs_pb17.TriggerMetadata.TriggerType.BLOCK]: "block" /* Block */,
-    [avs_pb17.TriggerMetadata.TriggerType.EVENT]: "event" /* Event */,
-    [avs_pb17.TriggerMetadata.TriggerType.MANUAL]: "manual" /* Manual */,
-    [avs_pb17.TriggerMetadata.TriggerType.UNSET]: "unset" /* Unset */
+    [avs_pb17.TriggerReason.TriggerType.FIXEDTIME]: "fixed_time" /* FixedTime */,
+    [avs_pb17.TriggerReason.TriggerType.CRON]: "cron" /* Cron */,
+    [avs_pb17.TriggerReason.TriggerType.BLOCK]: "block" /* Block */,
+    [avs_pb17.TriggerReason.TriggerType.EVENT]: "event" /* Event */,
+    [avs_pb17.TriggerReason.TriggerType.MANUAL]: "manual" /* Manual */,
+    [avs_pb17.TriggerReason.TriggerType.UNSET]: "unset" /* Unset */
   };
   return conversionMap[grpcType];
 };
-var TriggerMetadata2 = class _TriggerMetadata {
+var TriggerReason2 = class _TriggerReason {
   constructor(props) {
     this.type = props.type;
     switch (props.type) {
@@ -8115,7 +9005,7 @@ var TriggerMetadata2 = class _TriggerMetadata {
     if (!data) {
       return void 0;
     }
-    return new _TriggerMetadata({
+    return new _TriggerReason({
       type: convertTriggerType(data.getType()),
       blockNumber: data.getBlockNumber(),
       epoch: data.getEpoch(),
@@ -8124,28 +9014,28 @@ var TriggerMetadata2 = class _TriggerMetadata {
     });
   }
   toRequest() {
-    const request = new avs_pb17.TriggerMetadata();
+    const request = new avs_pb17.TriggerReason();
     switch (this.type) {
       case "fixed_time" /* FixedTime */:
-        request.setType(avs_pb17.TriggerMetadata.TriggerType.FIXEDTIME);
+        request.setType(avs_pb17.TriggerReason.TriggerType.FIXEDTIME);
         if (this.epoch) {
           request.setEpoch(this.epoch);
         }
         break;
       case "cron" /* Cron */:
-        request.setType(avs_pb17.TriggerMetadata.TriggerType.CRON);
+        request.setType(avs_pb17.TriggerReason.TriggerType.CRON);
         if (this.epoch) {
           request.setEpoch(this.epoch);
         }
         break;
       case "block" /* Block */:
-        request.setType(avs_pb17.TriggerMetadata.TriggerType.BLOCK);
+        request.setType(avs_pb17.TriggerReason.TriggerType.BLOCK);
         if (this.blockNumber) {
           request.setBlockNumber(this.blockNumber);
         }
         break;
       case "event" /* Event */:
-        request.setType(avs_pb17.TriggerMetadata.TriggerType.EVENT);
+        request.setType(avs_pb17.TriggerReason.TriggerType.EVENT);
         if (this.blockNumber) {
           request.setBlockNumber(this.blockNumber);
         }
@@ -8157,10 +9047,10 @@ var TriggerMetadata2 = class _TriggerMetadata {
         }
         break;
       case "manual" /* Manual */:
-        request.setType(avs_pb17.TriggerMetadata.TriggerType.MANUAL);
+        request.setType(avs_pb17.TriggerReason.TriggerType.MANUAL);
         break;
       case "unset" /* Unset */:
-        request.setType(avs_pb17.TriggerMetadata.TriggerType.UNSET);
+        request.setType(avs_pb17.TriggerReason.TriggerType.UNSET);
         break;
       default:
         throw new Error("Unsupported trigger type");
@@ -8168,7 +9058,7 @@ var TriggerMetadata2 = class _TriggerMetadata {
     return request;
   }
 };
-var metadata_default = TriggerMetadata2;
+var reason_default = TriggerReason2;
 
 // src/models/step.ts
 var avs_pb18 = __toESM(require_avs_pb());
@@ -8181,6 +9071,7 @@ var Step = class _Step {
     this.error = props.error;
     this.startAt = props.startAt;
     this.endAt = props.endAt;
+    this.inputsList = props.inputsList;
   }
   static fromResponse(step) {
     return new _Step({
@@ -8190,7 +9081,8 @@ var Step = class _Step {
       log: step.getLog(),
       error: step.getError(),
       startAt: step.getStartAt(),
-      endAt: step.getEndAt()
+      endAt: step.getEndAt(),
+      inputsList: step.getInputsList()
     });
   }
   toRequest() {
@@ -8202,6 +9094,7 @@ var Step = class _Step {
     step.setError(this.error);
     step.setStartAt(this.startAt);
     step.setEndAt(this.endAt);
+    step.setInputsList(this.inputsList);
     return step;
   }
 };
@@ -8215,40 +9108,67 @@ var Execution3 = class _Execution {
     this.endAt = props.endAt;
     this.success = props.success;
     this.error = props.error;
-    this.triggerMetadata = props.triggerMetadata;
-    this.result = props.result;
     this.stepsList = props.stepsList;
+    this.triggerName = props.triggerName;
+    this.triggerReason = props.triggerReason;
+    this.outputData = props.outputData;
   }
   static fromResponse(execution) {
+    const outputDataType = execution.getOutputDataCase();
+    let outputData;
+    switch (outputDataType) {
+      case avs_pb19.Execution.OutputDataCase.EVM_LOG:
+        outputData = execution.getEvmLog()?.toObject();
+        break;
+      case avs_pb19.Execution.OutputDataCase.TRANSFER_LOG:
+        outputData = execution.getTransferLog()?.toObject();
+        break;
+      case avs_pb19.Execution.OutputDataCase.BLOCK:
+        outputData = execution.getBlock()?.toObject();
+        break;
+      case avs_pb19.Execution.OutputDataCase.TIME:
+        outputData = execution.getTime()?.toObject();
+        break;
+    }
     return new _Execution({
       id: execution.getId(),
       startAt: execution.getStartAt(),
       endAt: execution.getEndAt(),
       success: execution.getSuccess(),
       error: execution.getError(),
-      triggerMetadata: metadata_default.fromResponse(
-        execution.getTriggerMetadata()
-      ),
-      result: execution.getResult(),
-      stepsList: execution.getStepsList().map((step) => step_default.fromResponse(step))
+      triggerName: execution.getTriggerName(),
+      triggerReason: reason_default.fromResponse(execution.getReason()),
+      stepsList: execution.getStepsList().map((step) => step_default.fromResponse(step)),
+      outputData
     });
   }
+  // Client side does not generate the exeuction, so there’s no toRequest() method
+};
+var execution_default = Execution3;
+
+// src/models/secret.ts
+var avs_pb20 = __toESM(require_avs_pb());
+var Secret = class {
+  constructor(props) {
+    this.name = props.name;
+    this.secret = props.secret;
+    this.workflowId = props.workflowId;
+    this.orgId = props.orgId;
+  }
   toRequest() {
-    const execution = new avs_pb19.Execution();
-    execution.setId(this.id);
-    execution.setStartAt(this.startAt);
-    execution.setEndAt(this.endAt);
-    execution.setSuccess(this.success);
-    execution.setError(this.error);
-    execution.setStepsList(this.stepsList.map((step) => step.toRequest()));
-    if (this.triggerMetadata) {
-      execution.setTriggerMetadata(this.triggerMetadata.toRequest());
-    }
-    execution.setResult(this.result);
-    return execution;
+    const request = new avs_pb20.CreateOrUpdateSecretReq();
+    request.setName(this.name);
+    request.setSecret(this.secret);
+    if (this.orgId) {
+      request.setOrgId(this.orgId);
+    }
+    if (this.workflowId) {
+      request.setWorkflowId(this.workflowId);
+    }
+    return request;
   }
 };
-var execution_default = Execution3;
+var secret_default = Secret;
 
 // src/index.ts
 var BaseClient = class {
@@ -8293,7 +9213,7 @@ var BaseClient = class {
     expiredAt,
     apiKey
   }) {
-    const request = new avs_pb20.GetKeyReq();
+    const request = new avs_pb21.GetKeyReq();
     request.setChainId(chainId);
     request.setOwner(address);
     const issueTs = import_timestamp_pb.Timestamp.fromDate(issuedAt);
@@ -8320,7 +9240,7 @@ var BaseClient = class {
     expiredAt,
     signature
   }) {
-    const request = new avs_pb20.GetKeyReq();
+    const request = new avs_pb21.GetKeyReq();
     request.setChainId(chainId);
     request.setOwner(address);
     const issueTs = import_timestamp_pb.Timestamp.fromDate(issuedAt);
@@ -8399,7 +9319,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<SmartWallet[]>} - The list of SmartWallet objects
    */
   async getWallets(options) {
-    const request = new avs_pb20.ListWalletReq();
+    const request = new avs_pb21.ListWalletReq();
     const result = await this.sendGrpcRequest("listWallets", request, options);
     return result.getItemsList().map((item) => item.toObject());
   }
@@ -8411,7 +9331,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<SmartWallet>} - The added SmartWallet object
    */
   async getWallet({ salt, factoryAddress }, options) {
-    const request = new avs_pb20.GetWalletReq();
+    const request = new avs_pb21.GetWalletReq();
     request.setSalt(salt);
     if (factoryAddress) {
       request.setFactoryAddress(factoryAddress);
@@ -8453,7 +9373,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ cursor: string; result: Workflow[] }>} - The list of Workflow objects
    */
   async getWorkflows(addresses, options) {
-    const request = new avs_pb20.ListTasksReq();
+    const request = new avs_pb21.ListTasksReq();
     for (const a of addresses) {
       request.addSmartWalletAddress(a);
     }
@@ -8478,7 +9398,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ cursor: string; result: Execution[] }>} - The list of Executions
    */
   async getExecutions(workflows, options) {
-    const request = new avs_pb20.ListExecutionsReq();
+    const request = new avs_pb21.ListExecutionsReq();
     request.setTaskIdsList(workflows);
     if (options?.cursor && options?.cursor != "") {
       request.setCursor(options.cursor);
@@ -8499,7 +9419,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<Execution>} - The result execution if it is existed
    */
   async getExecution(taskId, executionId, options) {
-    const request = new avs_pb20.ExecutionReq();
+    const request = new avs_pb21.ExecutionReq();
     request.setTaskId(taskId);
     request.setExecutionId(executionId);
     const result = await this.sendGrpcRequest("getExecution", request, options);
@@ -8516,7 +9436,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<ExecutionStatus>} - The result execution if it is existed
    */
   async getExecutionStatus(taskId, executionId, options) {
-    const request = new avs_pb20.ExecutionReq();
+    const request = new avs_pb21.ExecutionReq();
     request.setTaskId(taskId);
     request.setExecutionId(executionId);
     const result = await this.sendGrpcRequest("getExecutionStatus", request, options);
@@ -8529,7 +9449,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<Workflow>} - The Workflow object
    */
   async getWorkflow(id, options) {
-    const request = new avs_pb20.IdReq();
+    const request = new avs_pb21.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "getTask",
@@ -8548,12 +9468,12 @@ var Client = class extends BaseClient {
    */
   async triggerWorkflow({
     id,
-    data,
+    reason,
     isBlocking = false
   }, options) {
-    const request = new avs_pb20.UserTriggerTaskReq();
+    const request = new avs_pb21.UserTriggerTaskReq();
     request.setTaskId(id);
-    request.setTriggerMetadata(new metadata_default(data).toRequest());
+    request.setReason(new reason_default(reason).toRequest());
     request.setIsBlocking(isBlocking);
     const result = await this.sendGrpcRequest("triggerTask", request, options);
     return result.toObject();
@@ -8565,7 +9485,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - Whether the workflow was successfully canceled
    */
   async cancelWorkflow(id, options) {
-    const request = new avs_pb20.IdReq();
+    const request = new avs_pb21.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "cancelTask",
@@ -8581,7 +9501,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - Whether the workflow was successfully deleted
    */
   async deleteWorkflow(id, options) {
-    const request = new avs_pb20.IdReq();
+    const request = new avs_pb21.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "deleteTask",
@@ -8591,7 +9511,7 @@ var Client = class extends BaseClient {
     return result.getValue();
   }
   async createSecret(name, value, options) {
-    const request = new avs_pb20.CreateOrUpdateSecretReq();
+    const request = new avs_pb21.CreateOrUpdateSecretReq();
     request.setName(name);
     request.setSecret(value);
     if (options?.workflowId) {
@@ -8610,7 +9530,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - Whether the secret was successfully updated
    */
   async updateSecret(name, value, options) {
-    const request = new avs_pb20.CreateOrUpdateSecretReq();
+    const request = new avs_pb21.CreateOrUpdateSecretReq();
     request.setName(name);
     request.setSecret(value);
     if (options?.workflowId) {
@@ -8629,7 +9549,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<ListSecretResponse[]>} - The list of secrets
    */
   async listSecrets(options) {
-    const request = new avs_pb20.ListSecretsReq();
+    const request = new avs_pb21.ListSecretsReq();
     if (options?.workflowId) {
       request.setWorkflowId(options.workflowId);
     }
@@ -8651,7 +9571,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<boolean>} - Whether the secret was successfully deleted
    */
   async deleteSecret(name, options) {
-    const request = new avs_pb20.DeleteSecretReq();
+    const request = new avs_pb21.DeleteSecretReq();
     request.setName(name);
     if (options?.workflowId) {
       request.setWorkflowId(options.workflowId);
@@ -8668,6 +9588,7 @@ var Client = class extends BaseClient {
   AUTH_KEY_HEADER,
   BlockTrigger,
   BranchNode,
+  Client,
   ContractReadNode,
   ContractWriteNode,
   CronTrigger,
@@ -8685,10 +9606,11 @@ var Client = class extends BaseClient {
   Node,
   NodeFactory,
   RestAPINode,
+  Secret,
   Step,
   Trigger,
   TriggerFactory,
-  TriggerMetadata,
+  TriggerReason,
   TriggerType,
   Workflow,
   WorkflowStatus