@avaprotocol/sdk-js 2.8.1 → 2.9.1

package/dist/index.js

@@ -54,6 +54,9 @@ var require_avs_pb = __commonJS({
     var google_protobuf_struct_pb5 = require("google-protobuf/google/protobuf/struct_pb.js");
     goog.object.extend(proto, google_protobuf_struct_pb5);
     goog.exportSymbol("proto.aggregator.AutomationFee", null, global);
+    goog.exportSymbol("proto.aggregator.BalanceNode", null, global);
+    goog.exportSymbol("proto.aggregator.BalanceNode.Config", null, global);
+    goog.exportSymbol("proto.aggregator.BalanceNode.Output", null, global);
     goog.exportSymbol("proto.aggregator.BlockTrigger", null, global);
     goog.exportSymbol("proto.aggregator.BlockTrigger.Config", null, global);
     goog.exportSymbol("proto.aggregator.BlockTrigger.Output", null, global);
@@ -505,6 +508,27 @@ var require_avs_pb = __commonJS({
     if (goog.DEBUG && !COMPILED) {
       proto.aggregator.CustomCodeNode.Output.displayName = "proto.aggregator.CustomCodeNode.Output";
     }
+    proto.aggregator.BalanceNode = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.BalanceNode, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.BalanceNode.displayName = "proto.aggregator.BalanceNode";
+    }
+    proto.aggregator.BalanceNode.Config = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.BalanceNode.Config.repeatedFields_, null);
+    };
+    goog.inherits(proto.aggregator.BalanceNode.Config, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.BalanceNode.Config.displayName = "proto.aggregator.BalanceNode.Config";
+    }
+    proto.aggregator.BalanceNode.Output = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.BalanceNode.Output, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.BalanceNode.Output.displayName = "proto.aggregator.BalanceNode.Output";
+    }
     proto.aggregator.BranchNode = function(opt_data) {
       jspb.Message.initialize(this, opt_data, 0, -1, null, null);
     };
@@ -2733,7 +2757,8 @@ var require_avs_pb = __commonJS({
         var f, obj = {
           data: (f = msg.getData()) && google_protobuf_struct_pb5.Value.toObject(includeInstance, f),
           headersMap: (f = msg.getHeadersMap()) ? f.toObject(includeInstance, void 0) : [],
-          pathparamsMap: (f = msg.getPathparamsMap()) ? f.toObject(includeInstance, void 0) : []
+          pathparamsMap: (f = msg.getPathparamsMap()) ? f.toObject(includeInstance, void 0) : [],
+          lang: jspb.Message.getFieldWithDefault(msg, 4, 0)
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -2770,6 +2795,13 @@ var require_avs_pb = __commonJS({
               jspb.Map.deserializeBinary(message, reader2, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", "");
             });
             break;
+          case 4:
+            var value = (
+              /** @type {!proto.aggregator.Lang} */
+              reader.readEnum()
+            );
+            msg.setLang(value);
+            break;
           default:
             reader.skipField();
             break;
@@ -2800,6 +2832,13 @@ var require_avs_pb = __commonJS({
       if (f && f.getLength() > 0) {
         f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString);
       }
+      f = message.getLang();
+      if (f !== 0) {
+        writer.writeEnum(
+          4,
+          f
+        );
+      }
     };
     proto.aggregator.ManualTrigger.Config.prototype.getData = function() {
       return (
@@ -2846,6 +2885,15 @@ var require_avs_pb = __commonJS({
       this.getPathparamsMap().clear();
       return this;
     };
+    proto.aggregator.ManualTrigger.Config.prototype.getLang = function() {
+      return (
+        /** @type {!proto.aggregator.Lang} */
+        jspb.Message.getFieldWithDefault(this, 4, 0)
+      );
+    };
+    proto.aggregator.ManualTrigger.Config.prototype.setLang = function(value) {
+      return jspb.Message.setProto3EnumField(this, 4, value);
+    };
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.ManualTrigger.Output.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.ManualTrigger.Output.toObject(opt_includeInstance, this);
@@ -5544,6 +5592,335 @@ var require_avs_pb = __commonJS({
     proto.aggregator.CustomCodeNode.prototype.hasConfig = function() {
       return jspb.Message.getField(this, 1) != null;
     };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.BalanceNode.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.BalanceNode.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.BalanceNode.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          config: (f = msg.getConfig()) && proto.aggregator.BalanceNode.Config.toObject(includeInstance, f)
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.BalanceNode.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.BalanceNode();
+      return proto.aggregator.BalanceNode.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.BalanceNode.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = new proto.aggregator.BalanceNode.Config();
+            reader.readMessage(value, proto.aggregator.BalanceNode.Config.deserializeBinaryFromReader);
+            msg.setConfig(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.BalanceNode.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.BalanceNode.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.BalanceNode.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getConfig();
+      if (f != null) {
+        writer.writeMessage(
+          1,
+          f,
+          proto.aggregator.BalanceNode.Config.serializeBinaryToWriter
+        );
+      }
+    };
+    proto.aggregator.BalanceNode.Config.repeatedFields_ = [6];
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.BalanceNode.Config.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.BalanceNode.Config.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.BalanceNode.Config.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          address: jspb.Message.getFieldWithDefault(msg, 1, ""),
+          chain: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          includeSpam: jspb.Message.getBooleanFieldWithDefault(msg, 3, false),
+          includeZeroBalances: jspb.Message.getBooleanFieldWithDefault(msg, 4, false),
+          minUsdValueCents: jspb.Message.getFieldWithDefault(msg, 5, 0),
+          tokenAddressesList: (f = jspb.Message.getRepeatedField(msg, 6)) == null ? void 0 : f
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.BalanceNode.Config.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.BalanceNode.Config();
+      return proto.aggregator.BalanceNode.Config.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.BalanceNode.Config.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.setChain(value);
+            break;
+          case 3:
+            var value = (
+              /** @type {boolean} */
+              reader.readBool()
+            );
+            msg.setIncludeSpam(value);
+            break;
+          case 4:
+            var value = (
+              /** @type {boolean} */
+              reader.readBool()
+            );
+            msg.setIncludeZeroBalances(value);
+            break;
+          case 5:
+            var value = (
+              /** @type {number} */
+              reader.readInt64()
+            );
+            msg.setMinUsdValueCents(value);
+            break;
+          case 6:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.addTokenAddresses(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.BalanceNode.Config.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.BalanceNode.Config.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.BalanceNode.Config.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getAddress();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
+      }
+      f = message.getChain();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
+      }
+      f = message.getIncludeSpam();
+      if (f) {
+        writer.writeBool(
+          3,
+          f
+        );
+      }
+      f = message.getIncludeZeroBalances();
+      if (f) {
+        writer.writeBool(
+          4,
+          f
+        );
+      }
+      f = message.getMinUsdValueCents();
+      if (f !== 0) {
+        writer.writeInt64(
+          5,
+          f
+        );
+      }
+      f = message.getTokenAddressesList();
+      if (f.length > 0) {
+        writer.writeRepeatedString(
+          6,
+          f
+        );
+      }
+    };
+    proto.aggregator.BalanceNode.Config.prototype.getAddress = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.BalanceNode.Config.prototype.setAddress = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    proto.aggregator.BalanceNode.Config.prototype.getChain = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
+      );
+    };
+    proto.aggregator.BalanceNode.Config.prototype.setChain = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
+    };
+    proto.aggregator.BalanceNode.Config.prototype.getIncludeSpam = function() {
+      return (
+        /** @type {boolean} */
+        jspb.Message.getBooleanFieldWithDefault(this, 3, false)
+      );
+    };
+    proto.aggregator.BalanceNode.Config.prototype.setIncludeSpam = function(value) {
+      return jspb.Message.setProto3BooleanField(this, 3, value);
+    };
+    proto.aggregator.BalanceNode.Config.prototype.getIncludeZeroBalances = function() {
+      return (
+        /** @type {boolean} */
+        jspb.Message.getBooleanFieldWithDefault(this, 4, false)
+      );
+    };
+    proto.aggregator.BalanceNode.Config.prototype.setIncludeZeroBalances = function(value) {
+      return jspb.Message.setProto3BooleanField(this, 4, value);
+    };
+    proto.aggregator.BalanceNode.Config.prototype.getMinUsdValueCents = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 5, 0)
+      );
+    };
+    proto.aggregator.BalanceNode.Config.prototype.setMinUsdValueCents = function(value) {
+      return jspb.Message.setProto3IntField(this, 5, value);
+    };
+    proto.aggregator.BalanceNode.Config.prototype.getTokenAddressesList = function() {
+      return (
+        /** @type {!Array<string>} */
+        jspb.Message.getRepeatedField(this, 6)
+      );
+    };
+    proto.aggregator.BalanceNode.Config.prototype.setTokenAddressesList = function(value) {
+      return jspb.Message.setField(this, 6, value || []);
+    };
+    proto.aggregator.BalanceNode.Config.prototype.addTokenAddresses = function(value, opt_index) {
+      return jspb.Message.addToRepeatedField(this, 6, value, opt_index);
+    };
+    proto.aggregator.BalanceNode.Config.prototype.clearTokenAddressesList = function() {
+      return this.setTokenAddressesList([]);
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.BalanceNode.Output.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.BalanceNode.Output.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.BalanceNode.Output.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          data: (f = msg.getData()) && google_protobuf_struct_pb5.Value.toObject(includeInstance, f)
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.BalanceNode.Output.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.BalanceNode.Output();
+      return proto.aggregator.BalanceNode.Output.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.BalanceNode.Output.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = new google_protobuf_struct_pb5.Value();
+            reader.readMessage(value, google_protobuf_struct_pb5.Value.deserializeBinaryFromReader);
+            msg.setData(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.BalanceNode.Output.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.BalanceNode.Output.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.BalanceNode.Output.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getData();
+      if (f != null) {
+        writer.writeMessage(
+          1,
+          f,
+          google_protobuf_struct_pb5.Value.serializeBinaryToWriter
+        );
+      }
+    };
+    proto.aggregator.BalanceNode.Output.prototype.getData = function() {
+      return (
+        /** @type{?proto.google.protobuf.Value} */
+        jspb.Message.getWrapperField(this, google_protobuf_struct_pb5.Value, 1)
+      );
+    };
+    proto.aggregator.BalanceNode.Output.prototype.setData = function(value) {
+      return jspb.Message.setWrapperField(this, 1, value);
+    };
+    proto.aggregator.BalanceNode.Output.prototype.clearData = function() {
+      return this.setData(void 0);
+    };
+    proto.aggregator.BalanceNode.Output.prototype.hasData = function() {
+      return jspb.Message.getField(this, 1) != null;
+    };
+    proto.aggregator.BalanceNode.prototype.getConfig = function() {
+      return (
+        /** @type{?proto.aggregator.BalanceNode.Config} */
+        jspb.Message.getWrapperField(this, proto.aggregator.BalanceNode.Config, 1)
+      );
+    };
+    proto.aggregator.BalanceNode.prototype.setConfig = function(value) {
+      return jspb.Message.setWrapperField(this, 1, value);
+    };
+    proto.aggregator.BalanceNode.prototype.clearConfig = function() {
+      return this.setConfig(void 0);
+    };
+    proto.aggregator.BalanceNode.prototype.hasConfig = function() {
+      return jspb.Message.getField(this, 1) != null;
+    };
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.BranchNode.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.BranchNode.toObject(opt_includeInstance, this);
@@ -6670,7 +7047,7 @@ var require_avs_pb = __commonJS({
     proto.aggregator.TaskEdge.prototype.setTarget = function(value) {
       return jspb.Message.setProto3StringField(this, 3, value);
     };
-    proto.aggregator.TaskNode.oneofGroups_ = [[10, 11, 12, 13, 14, 15, 16, 17, 18]];
+    proto.aggregator.TaskNode.oneofGroups_ = [[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]];
     proto.aggregator.TaskNode.TaskTypeCase = {
       TASK_TYPE_NOT_SET: 0,
       ETH_TRANSFER: 10,
@@ -6681,7 +7058,8 @@ var require_avs_pb = __commonJS({
       BRANCH: 15,
       FILTER: 16,
       LOOP: 17,
-      CUSTOM_CODE: 18
+      CUSTOM_CODE: 18,
+      BALANCE: 19
     };
     proto.aggregator.TaskNode.prototype.getTaskTypeCase = function() {
       return (
@@ -6706,7 +7084,8 @@ var require_avs_pb = __commonJS({
           branch: (f = msg.getBranch()) && proto.aggregator.BranchNode.toObject(includeInstance, f),
           filter: (f = msg.getFilter()) && proto.aggregator.FilterNode.toObject(includeInstance, f),
           loop: (f = msg.getLoop()) && proto.aggregator.LoopNode.toObject(includeInstance, f),
-          customCode: (f = msg.getCustomCode()) && proto.aggregator.CustomCodeNode.toObject(includeInstance, f)
+          customCode: (f = msg.getCustomCode()) && proto.aggregator.CustomCodeNode.toObject(includeInstance, f),
+          balance: (f = msg.getBalance()) && proto.aggregator.BalanceNode.toObject(includeInstance, f)
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -6792,6 +7171,11 @@ var require_avs_pb = __commonJS({
             reader.readMessage(value, proto.aggregator.CustomCodeNode.deserializeBinaryFromReader);
             msg.setCustomCode(value);
             break;
+          case 19:
+            var value = new proto.aggregator.BalanceNode();
+            reader.readMessage(value, proto.aggregator.BalanceNode.deserializeBinaryFromReader);
+            msg.setBalance(value);
+            break;
           default:
             reader.skipField();
             break;
@@ -6899,6 +7283,14 @@ var require_avs_pb = __commonJS({
           proto.aggregator.CustomCodeNode.serializeBinaryToWriter
         );
       }
+      f = message.getBalance();
+      if (f != null) {
+        writer.writeMessage(
+          19,
+          f,
+          proto.aggregator.BalanceNode.serializeBinaryToWriter
+        );
+      }
     };
     proto.aggregator.TaskNode.prototype.getId = function() {
       return (
@@ -7062,6 +7454,21 @@ var require_avs_pb = __commonJS({
     proto.aggregator.TaskNode.prototype.hasCustomCode = function() {
       return jspb.Message.getField(this, 18) != null;
     };
+    proto.aggregator.TaskNode.prototype.getBalance = function() {
+      return (
+        /** @type{?proto.aggregator.BalanceNode} */
+        jspb.Message.getWrapperField(this, proto.aggregator.BalanceNode, 19)
+      );
+    };
+    proto.aggregator.TaskNode.prototype.setBalance = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 19, proto.aggregator.TaskNode.oneofGroups_[0], value);
+    };
+    proto.aggregator.TaskNode.prototype.clearBalance = function() {
+      return this.setBalance(void 0);
+    };
+    proto.aggregator.TaskNode.prototype.hasBalance = function() {
+      return jspb.Message.getField(this, 19) != null;
+    };
     proto.aggregator.Execution.repeatedFields_ = [8];
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.Execution.prototype.toObject = function(opt_includeInstance) {
@@ -7227,7 +7634,7 @@ var require_avs_pb = __commonJS({
       }
     };
     proto.aggregator.Execution.Step.repeatedFields_ = [16];
-    proto.aggregator.Execution.Step.oneofGroups_ = [[20, 21, 22, 23, 24, 3, 4, 5, 6, 7, 8, 9, 10, 11]];
+    proto.aggregator.Execution.Step.oneofGroups_ = [[20, 21, 22, 23, 24, 3, 4, 5, 6, 7, 8, 9, 10, 11, 30]];
     proto.aggregator.Execution.Step.OutputDataCase = {
       OUTPUT_DATA_NOT_SET: 0,
       BLOCK_TRIGGER: 20,
@@ -7243,7 +7650,8 @@ var require_avs_pb = __commonJS({
       REST_API: 8,
       BRANCH: 9,
       FILTER: 10,
-      LOOP: 11
+      LOOP: 11,
+      BALANCE: 30
     };
     proto.aggregator.Execution.Step.prototype.getOutputDataCase = function() {
       return (
@@ -7285,6 +7693,7 @@ var require_avs_pb = __commonJS({
           branch: (f = msg.getBranch()) && proto.aggregator.BranchNode.Output.toObject(includeInstance, f),
           filter: (f = msg.getFilter()) && proto.aggregator.FilterNode.Output.toObject(includeInstance, f),
           loop: (f = msg.getLoop()) && proto.aggregator.LoopNode.Output.toObject(includeInstance, f),
+          balance: (f = msg.getBalance()) && proto.aggregator.BalanceNode.Output.toObject(includeInstance, f),
           startAt: jspb.Message.getFieldWithDefault(msg, 14, 0),
           endAt: jspb.Message.getFieldWithDefault(msg, 15, 0)
         };
@@ -7468,6 +7877,11 @@ var require_avs_pb = __commonJS({
             reader.readMessage(value, proto.aggregator.LoopNode.Output.deserializeBinaryFromReader);
             msg.setLoop(value);
             break;
+          case 30:
+            var value = new proto.aggregator.BalanceNode.Output();
+            reader.readMessage(value, proto.aggregator.BalanceNode.Output.deserializeBinaryFromReader);
+            msg.setBalance(value);
+            break;
           case 14:
             var value = (
               /** @type {number} */
@@ -7709,6 +8123,14 @@ var require_avs_pb = __commonJS({
           proto.aggregator.LoopNode.Output.serializeBinaryToWriter
         );
       }
+      f = message.getBalance();
+      if (f != null) {
+        writer.writeMessage(
+          30,
+          f,
+          proto.aggregator.BalanceNode.Output.serializeBinaryToWriter
+        );
+      }
       f = message.getStartAt();
       if (f !== 0) {
         writer.writeInt64(
@@ -8084,6 +8506,21 @@ var require_avs_pb = __commonJS({
     proto.aggregator.Execution.Step.prototype.hasLoop = function() {
       return jspb.Message.getField(this, 11) != null;
     };
+    proto.aggregator.Execution.Step.prototype.getBalance = function() {
+      return (
+        /** @type{?proto.aggregator.BalanceNode.Output} */
+        jspb.Message.getWrapperField(this, proto.aggregator.BalanceNode.Output, 30)
+      );
+    };
+    proto.aggregator.Execution.Step.prototype.setBalance = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 30, proto.aggregator.Execution.Step.oneofGroups_[0], value);
+    };
+    proto.aggregator.Execution.Step.prototype.clearBalance = function() {
+      return this.setBalance(void 0);
+    };
+    proto.aggregator.Execution.Step.prototype.hasBalance = function() {
+      return jspb.Message.getField(this, 30) != null;
+    };
     proto.aggregator.Execution.Step.prototype.getStartAt = function() {
       return (
         /** @type {number} */
@@ -14269,7 +14706,7 @@ var require_avs_pb = __commonJS({
       this.getInputVariablesMap().clear();
       return this;
     };
-    proto.aggregator.RunNodeWithInputsResp.oneofGroups_ = [[10, 11, 12, 13, 14, 15, 16, 17, 18]];
+    proto.aggregator.RunNodeWithInputsResp.oneofGroups_ = [[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]];
     proto.aggregator.RunNodeWithInputsResp.OutputDataCase = {
       OUTPUT_DATA_NOT_SET: 0,
       ETH_TRANSFER: 10,
@@ -14280,7 +14717,8 @@ var require_avs_pb = __commonJS({
       REST_API: 15,
       BRANCH: 16,
       FILTER: 17,
-      LOOP: 18
+      LOOP: 18,
+      BALANCE: 19
     };
     proto.aggregator.RunNodeWithInputsResp.prototype.getOutputDataCase = function() {
       return (
@@ -14307,7 +14745,8 @@ var require_avs_pb = __commonJS({
           restApi: (f = msg.getRestApi()) && proto.aggregator.RestAPINode.Output.toObject(includeInstance, f),
           branch: (f = msg.getBranch()) && proto.aggregator.BranchNode.Output.toObject(includeInstance, f),
           filter: (f = msg.getFilter()) && proto.aggregator.FilterNode.Output.toObject(includeInstance, f),
-          loop: (f = msg.getLoop()) && proto.aggregator.LoopNode.Output.toObject(includeInstance, f)
+          loop: (f = msg.getLoop()) && proto.aggregator.LoopNode.Output.toObject(includeInstance, f),
+          balance: (f = msg.getBalance()) && proto.aggregator.BalanceNode.Output.toObject(includeInstance, f)
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -14403,6 +14842,11 @@ var require_avs_pb = __commonJS({
             reader.readMessage(value, proto.aggregator.LoopNode.Output.deserializeBinaryFromReader);
             msg.setLoop(value);
             break;
+          case 19:
+            var value = new proto.aggregator.BalanceNode.Output();
+            reader.readMessage(value, proto.aggregator.BalanceNode.Output.deserializeBinaryFromReader);
+            msg.setBalance(value);
+            break;
           default:
             reader.skipField();
             break;
@@ -14526,6 +14970,14 @@ var require_avs_pb = __commonJS({
           proto.aggregator.LoopNode.Output.serializeBinaryToWriter
         );
       }
+      f = message.getBalance();
+      if (f != null) {
+        writer.writeMessage(
+          19,
+          f,
+          proto.aggregator.BalanceNode.Output.serializeBinaryToWriter
+        );
+      }
     };
     proto.aggregator.RunNodeWithInputsResp.prototype.getSuccess = function() {
       return (
@@ -14719,6 +15171,21 @@ var require_avs_pb = __commonJS({
     proto.aggregator.RunNodeWithInputsResp.prototype.hasLoop = function() {
       return jspb.Message.getField(this, 18) != null;
     };
+    proto.aggregator.RunNodeWithInputsResp.prototype.getBalance = function() {
+      return (
+        /** @type{?proto.aggregator.BalanceNode.Output} */
+        jspb.Message.getWrapperField(this, proto.aggregator.BalanceNode.Output, 19)
+      );
+    };
+    proto.aggregator.RunNodeWithInputsResp.prototype.setBalance = function(value) {
+      return jspb.Message.setOneofWrapperField(this, 19, proto.aggregator.RunNodeWithInputsResp.oneofGroups_[0], value);
+    };
+    proto.aggregator.RunNodeWithInputsResp.prototype.clearBalance = function() {
+      return this.setBalance(void 0);
+    };
+    proto.aggregator.RunNodeWithInputsResp.prototype.hasBalance = function() {
+      return jspb.Message.getField(this, 19) != null;
+    };
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.RunTriggerReq.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.RunTriggerReq.toObject(opt_includeInstance, this);
@@ -17297,14 +17764,19 @@ var require_avs_pb = __commonJS({
       NODE_TYPE_CUSTOM_CODE: 6,
       NODE_TYPE_BRANCH: 7,
       NODE_TYPE_FILTER: 8,
-      NODE_TYPE_LOOP: 9
+      NODE_TYPE_LOOP: 9,
+      NODE_TYPE_BALANCE: 10
     };
     proto.aggregator.ExecutionMode = {
       EXECUTION_MODE_SEQUENTIAL: 0,
       EXECUTION_MODE_PARALLEL: 1
     };
     proto.aggregator.Lang = {
-      JAVASCRIPT: 0
+      LANG_UNSPECIFIED: 0,
+      LANG_JAVASCRIPT: 1,
+      LANG_JSON: 2,
+      LANG_GRAPHQL: 3,
+      LANG_HANDLEBARS: 4
     };
     proto.aggregator.ErrorCode = {
       ERROR_CODE_UNSPECIFIED: 0,
@@ -17370,457 +17842,457 @@ var require_avs_grpc_pb = __commonJS({
   "../../grpc_codegen/avs_grpc_pb.js"(exports2) {
     "use strict";
     var grpc = require("@grpc/grpc-js");
-    var avs_pb24 = require_avs_pb();
+    var avs_pb25 = require_avs_pb();
     var google_protobuf_struct_pb5 = require("google-protobuf/google/protobuf/struct_pb.js");
     function serialize_aggregator_CancelTaskResp(arg) {
-      if (!(arg instanceof avs_pb24.CancelTaskResp)) {
+      if (!(arg instanceof avs_pb25.CancelTaskResp)) {
         throw new Error("Expected argument of type aggregator.CancelTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CancelTaskResp(buffer_arg) {
-      return avs_pb24.CancelTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.CancelTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateOrUpdateSecretReq(arg) {
-      if (!(arg instanceof avs_pb24.CreateOrUpdateSecretReq)) {
+      if (!(arg instanceof avs_pb25.CreateOrUpdateSecretReq)) {
         throw new Error("Expected argument of type aggregator.CreateOrUpdateSecretReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateOrUpdateSecretReq(buffer_arg) {
-      return avs_pb24.CreateOrUpdateSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.CreateOrUpdateSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateSecretResp(arg) {
-      if (!(arg instanceof avs_pb24.CreateSecretResp)) {
+      if (!(arg instanceof avs_pb25.CreateSecretResp)) {
         throw new Error("Expected argument of type aggregator.CreateSecretResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateSecretResp(buffer_arg) {
-      return avs_pb24.CreateSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.CreateSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateTaskReq(arg) {
-      if (!(arg instanceof avs_pb24.CreateTaskReq)) {
+      if (!(arg instanceof avs_pb25.CreateTaskReq)) {
         throw new Error("Expected argument of type aggregator.CreateTaskReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateTaskReq(buffer_arg) {
-      return avs_pb24.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.CreateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_CreateTaskResp(arg) {
-      if (!(arg instanceof avs_pb24.CreateTaskResp)) {
+      if (!(arg instanceof avs_pb25.CreateTaskResp)) {
         throw new Error("Expected argument of type aggregator.CreateTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_CreateTaskResp(buffer_arg) {
-      return avs_pb24.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.CreateTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_DeleteSecretReq(arg) {
-      if (!(arg instanceof avs_pb24.DeleteSecretReq)) {
+      if (!(arg instanceof avs_pb25.DeleteSecretReq)) {
         throw new Error("Expected argument of type aggregator.DeleteSecretReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_DeleteSecretReq(buffer_arg) {
-      return avs_pb24.DeleteSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.DeleteSecretReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_DeleteSecretResp(arg) {
-      if (!(arg instanceof avs_pb24.DeleteSecretResp)) {
+      if (!(arg instanceof avs_pb25.DeleteSecretResp)) {
         throw new Error("Expected argument of type aggregator.DeleteSecretResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_DeleteSecretResp(buffer_arg) {
-      return avs_pb24.DeleteSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.DeleteSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_DeleteTaskResp(arg) {
-      if (!(arg instanceof avs_pb24.DeleteTaskResp)) {
+      if (!(arg instanceof avs_pb25.DeleteTaskResp)) {
         throw new Error("Expected argument of type aggregator.DeleteTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_DeleteTaskResp(buffer_arg) {
-      return avs_pb24.DeleteTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.DeleteTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_EstimateFeesReq(arg) {
-      if (!(arg instanceof avs_pb24.EstimateFeesReq)) {
+      if (!(arg instanceof avs_pb25.EstimateFeesReq)) {
         throw new Error("Expected argument of type aggregator.EstimateFeesReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_EstimateFeesReq(buffer_arg) {
-      return avs_pb24.EstimateFeesReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.EstimateFeesReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_EstimateFeesResp(arg) {
-      if (!(arg instanceof avs_pb24.EstimateFeesResp)) {
+      if (!(arg instanceof avs_pb25.EstimateFeesResp)) {
         throw new Error("Expected argument of type aggregator.EstimateFeesResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_EstimateFeesResp(buffer_arg) {
-      return avs_pb24.EstimateFeesResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.EstimateFeesResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_Execution(arg) {
-      if (!(arg instanceof avs_pb24.Execution)) {
+      if (!(arg instanceof avs_pb25.Execution)) {
         throw new Error("Expected argument of type aggregator.Execution");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_Execution(buffer_arg) {
-      return avs_pb24.Execution.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.Execution.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ExecutionReq(arg) {
-      if (!(arg instanceof avs_pb24.ExecutionReq)) {
+      if (!(arg instanceof avs_pb25.ExecutionReq)) {
         throw new Error("Expected argument of type aggregator.ExecutionReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ExecutionReq(buffer_arg) {
-      return avs_pb24.ExecutionReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.ExecutionReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ExecutionStatusResp(arg) {
-      if (!(arg instanceof avs_pb24.ExecutionStatusResp)) {
+      if (!(arg instanceof avs_pb25.ExecutionStatusResp)) {
         throw new Error("Expected argument of type aggregator.ExecutionStatusResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ExecutionStatusResp(buffer_arg) {
-      return avs_pb24.ExecutionStatusResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.ExecutionStatusResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionCountReq(arg) {
-      if (!(arg instanceof avs_pb24.GetExecutionCountReq)) {
+      if (!(arg instanceof avs_pb25.GetExecutionCountReq)) {
         throw new Error("Expected argument of type aggregator.GetExecutionCountReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetExecutionCountReq(buffer_arg) {
-      return avs_pb24.GetExecutionCountReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetExecutionCountReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionCountResp(arg) {
-      if (!(arg instanceof avs_pb24.GetExecutionCountResp)) {
+      if (!(arg instanceof avs_pb25.GetExecutionCountResp)) {
         throw new Error("Expected argument of type aggregator.GetExecutionCountResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetExecutionCountResp(buffer_arg) {
-      return avs_pb24.GetExecutionCountResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetExecutionCountResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionStatsReq(arg) {
-      if (!(arg instanceof avs_pb24.GetExecutionStatsReq)) {
+      if (!(arg instanceof avs_pb25.GetExecutionStatsReq)) {
         throw new Error("Expected argument of type aggregator.GetExecutionStatsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetExecutionStatsReq(buffer_arg) {
-      return avs_pb24.GetExecutionStatsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetExecutionStatsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetExecutionStatsResp(arg) {
-      if (!(arg instanceof avs_pb24.GetExecutionStatsResp)) {
+      if (!(arg instanceof avs_pb25.GetExecutionStatsResp)) {
         throw new Error("Expected argument of type aggregator.GetExecutionStatsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetExecutionStatsResp(buffer_arg) {
-      return avs_pb24.GetExecutionStatsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetExecutionStatsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetKeyReq(arg) {
-      if (!(arg instanceof avs_pb24.GetKeyReq)) {
+      if (!(arg instanceof avs_pb25.GetKeyReq)) {
         throw new Error("Expected argument of type aggregator.GetKeyReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetKeyReq(buffer_arg) {
-      return avs_pb24.GetKeyReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetKeyReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetSignatureFormatReq(arg) {
-      if (!(arg instanceof avs_pb24.GetSignatureFormatReq)) {
+      if (!(arg instanceof avs_pb25.GetSignatureFormatReq)) {
         throw new Error("Expected argument of type aggregator.GetSignatureFormatReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetSignatureFormatReq(buffer_arg) {
-      return avs_pb24.GetSignatureFormatReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetSignatureFormatReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetSignatureFormatResp(arg) {
-      if (!(arg instanceof avs_pb24.GetSignatureFormatResp)) {
+      if (!(arg instanceof avs_pb25.GetSignatureFormatResp)) {
         throw new Error("Expected argument of type aggregator.GetSignatureFormatResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetSignatureFormatResp(buffer_arg) {
-      return avs_pb24.GetSignatureFormatResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetSignatureFormatResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetTokenMetadataReq(arg) {
-      if (!(arg instanceof avs_pb24.GetTokenMetadataReq)) {
+      if (!(arg instanceof avs_pb25.GetTokenMetadataReq)) {
         throw new Error("Expected argument of type aggregator.GetTokenMetadataReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetTokenMetadataReq(buffer_arg) {
-      return avs_pb24.GetTokenMetadataReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetTokenMetadataReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetTokenMetadataResp(arg) {
-      if (!(arg instanceof avs_pb24.GetTokenMetadataResp)) {
+      if (!(arg instanceof avs_pb25.GetTokenMetadataResp)) {
         throw new Error("Expected argument of type aggregator.GetTokenMetadataResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetTokenMetadataResp(buffer_arg) {
-      return avs_pb24.GetTokenMetadataResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetTokenMetadataResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWalletReq(arg) {
-      if (!(arg instanceof avs_pb24.GetWalletReq)) {
+      if (!(arg instanceof avs_pb25.GetWalletReq)) {
         throw new Error("Expected argument of type aggregator.GetWalletReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWalletReq(buffer_arg) {
-      return avs_pb24.GetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWalletResp(arg) {
-      if (!(arg instanceof avs_pb24.GetWalletResp)) {
+      if (!(arg instanceof avs_pb25.GetWalletResp)) {
         throw new Error("Expected argument of type aggregator.GetWalletResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWalletResp(buffer_arg) {
-      return avs_pb24.GetWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWorkflowCountReq(arg) {
-      if (!(arg instanceof avs_pb24.GetWorkflowCountReq)) {
+      if (!(arg instanceof avs_pb25.GetWorkflowCountReq)) {
         throw new Error("Expected argument of type aggregator.GetWorkflowCountReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWorkflowCountReq(buffer_arg) {
-      return avs_pb24.GetWorkflowCountReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetWorkflowCountReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_GetWorkflowCountResp(arg) {
-      if (!(arg instanceof avs_pb24.GetWorkflowCountResp)) {
+      if (!(arg instanceof avs_pb25.GetWorkflowCountResp)) {
         throw new Error("Expected argument of type aggregator.GetWorkflowCountResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_GetWorkflowCountResp(buffer_arg) {
-      return avs_pb24.GetWorkflowCountResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.GetWorkflowCountResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_IdReq(arg) {
-      if (!(arg instanceof avs_pb24.IdReq)) {
+      if (!(arg instanceof avs_pb25.IdReq)) {
         throw new Error("Expected argument of type aggregator.IdReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_IdReq(buffer_arg) {
-      return avs_pb24.IdReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.IdReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_KeyResp(arg) {
-      if (!(arg instanceof avs_pb24.KeyResp)) {
+      if (!(arg instanceof avs_pb25.KeyResp)) {
         throw new Error("Expected argument of type aggregator.KeyResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_KeyResp(buffer_arg) {
-      return avs_pb24.KeyResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.KeyResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListExecutionsReq(arg) {
-      if (!(arg instanceof avs_pb24.ListExecutionsReq)) {
+      if (!(arg instanceof avs_pb25.ListExecutionsReq)) {
         throw new Error("Expected argument of type aggregator.ListExecutionsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListExecutionsReq(buffer_arg) {
-      return avs_pb24.ListExecutionsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.ListExecutionsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListExecutionsResp(arg) {
-      if (!(arg instanceof avs_pb24.ListExecutionsResp)) {
+      if (!(arg instanceof avs_pb25.ListExecutionsResp)) {
         throw new Error("Expected argument of type aggregator.ListExecutionsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListExecutionsResp(buffer_arg) {
-      return avs_pb24.ListExecutionsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.ListExecutionsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListSecretsReq(arg) {
-      if (!(arg instanceof avs_pb24.ListSecretsReq)) {
+      if (!(arg instanceof avs_pb25.ListSecretsReq)) {
         throw new Error("Expected argument of type aggregator.ListSecretsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListSecretsReq(buffer_arg) {
-      return avs_pb24.ListSecretsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.ListSecretsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListSecretsResp(arg) {
-      if (!(arg instanceof avs_pb24.ListSecretsResp)) {
+      if (!(arg instanceof avs_pb25.ListSecretsResp)) {
         throw new Error("Expected argument of type aggregator.ListSecretsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListSecretsResp(buffer_arg) {
-      return avs_pb24.ListSecretsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.ListSecretsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListTasksReq(arg) {
-      if (!(arg instanceof avs_pb24.ListTasksReq)) {
+      if (!(arg instanceof avs_pb25.ListTasksReq)) {
         throw new Error("Expected argument of type aggregator.ListTasksReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListTasksReq(buffer_arg) {
-      return avs_pb24.ListTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.ListTasksReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListTasksResp(arg) {
-      if (!(arg instanceof avs_pb24.ListTasksResp)) {
+      if (!(arg instanceof avs_pb25.ListTasksResp)) {
         throw new Error("Expected argument of type aggregator.ListTasksResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListTasksResp(buffer_arg) {
-      return avs_pb24.ListTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.ListTasksResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListWalletReq(arg) {
-      if (!(arg instanceof avs_pb24.ListWalletReq)) {
+      if (!(arg instanceof avs_pb25.ListWalletReq)) {
         throw new Error("Expected argument of type aggregator.ListWalletReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListWalletReq(buffer_arg) {
-      return avs_pb24.ListWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.ListWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_ListWalletResp(arg) {
-      if (!(arg instanceof avs_pb24.ListWalletResp)) {
+      if (!(arg instanceof avs_pb25.ListWalletResp)) {
         throw new Error("Expected argument of type aggregator.ListWalletResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_ListWalletResp(buffer_arg) {
-      return avs_pb24.ListWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.ListWalletResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_NonceRequest(arg) {
-      if (!(arg instanceof avs_pb24.NonceRequest)) {
+      if (!(arg instanceof avs_pb25.NonceRequest)) {
         throw new Error("Expected argument of type aggregator.NonceRequest");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_NonceRequest(buffer_arg) {
-      return avs_pb24.NonceRequest.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.NonceRequest.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_NonceResp(arg) {
-      if (!(arg instanceof avs_pb24.NonceResp)) {
+      if (!(arg instanceof avs_pb25.NonceResp)) {
         throw new Error("Expected argument of type aggregator.NonceResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_NonceResp(buffer_arg) {
-      return avs_pb24.NonceResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.NonceResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunNodeWithInputsReq(arg) {
-      if (!(arg instanceof avs_pb24.RunNodeWithInputsReq)) {
+      if (!(arg instanceof avs_pb25.RunNodeWithInputsReq)) {
         throw new Error("Expected argument of type aggregator.RunNodeWithInputsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_RunNodeWithInputsReq(buffer_arg) {
-      return avs_pb24.RunNodeWithInputsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.RunNodeWithInputsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunNodeWithInputsResp(arg) {
-      if (!(arg instanceof avs_pb24.RunNodeWithInputsResp)) {
+      if (!(arg instanceof avs_pb25.RunNodeWithInputsResp)) {
         throw new Error("Expected argument of type aggregator.RunNodeWithInputsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_RunNodeWithInputsResp(buffer_arg) {
-      return avs_pb24.RunNodeWithInputsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.RunNodeWithInputsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunTriggerReq(arg) {
-      if (!(arg instanceof avs_pb24.RunTriggerReq)) {
+      if (!(arg instanceof avs_pb25.RunTriggerReq)) {
         throw new Error("Expected argument of type aggregator.RunTriggerReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_RunTriggerReq(buffer_arg) {
-      return avs_pb24.RunTriggerReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.RunTriggerReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_RunTriggerResp(arg) {
-      if (!(arg instanceof avs_pb24.RunTriggerResp)) {
+      if (!(arg instanceof avs_pb25.RunTriggerResp)) {
         throw new Error("Expected argument of type aggregator.RunTriggerResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_RunTriggerResp(buffer_arg) {
-      return avs_pb24.RunTriggerResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.RunTriggerResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_SetWalletReq(arg) {
-      if (!(arg instanceof avs_pb24.SetWalletReq)) {
+      if (!(arg instanceof avs_pb25.SetWalletReq)) {
         throw new Error("Expected argument of type aggregator.SetWalletReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_SetWalletReq(buffer_arg) {
-      return avs_pb24.SetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.SetWalletReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_SimulateTaskReq(arg) {
-      if (!(arg instanceof avs_pb24.SimulateTaskReq)) {
+      if (!(arg instanceof avs_pb25.SimulateTaskReq)) {
         throw new Error("Expected argument of type aggregator.SimulateTaskReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_SimulateTaskReq(buffer_arg) {
-      return avs_pb24.SimulateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.SimulateTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_Task(arg) {
-      if (!(arg instanceof avs_pb24.Task)) {
+      if (!(arg instanceof avs_pb25.Task)) {
         throw new Error("Expected argument of type aggregator.Task");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_Task(buffer_arg) {
-      return avs_pb24.Task.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.Task.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_TriggerTaskReq(arg) {
-      if (!(arg instanceof avs_pb24.TriggerTaskReq)) {
+      if (!(arg instanceof avs_pb25.TriggerTaskReq)) {
         throw new Error("Expected argument of type aggregator.TriggerTaskReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_TriggerTaskReq(buffer_arg) {
-      return avs_pb24.TriggerTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.TriggerTaskReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_TriggerTaskResp(arg) {
-      if (!(arg instanceof avs_pb24.TriggerTaskResp)) {
+      if (!(arg instanceof avs_pb25.TriggerTaskResp)) {
         throw new Error("Expected argument of type aggregator.TriggerTaskResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_TriggerTaskResp(buffer_arg) {
-      return avs_pb24.TriggerTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.TriggerTaskResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_UpdateSecretResp(arg) {
-      if (!(arg instanceof avs_pb24.UpdateSecretResp)) {
+      if (!(arg instanceof avs_pb25.UpdateSecretResp)) {
         throw new Error("Expected argument of type aggregator.UpdateSecretResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_UpdateSecretResp(buffer_arg) {
-      return avs_pb24.UpdateSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.UpdateSecretResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_WithdrawFundsReq(arg) {
-      if (!(arg instanceof avs_pb24.WithdrawFundsReq)) {
+      if (!(arg instanceof avs_pb25.WithdrawFundsReq)) {
         throw new Error("Expected argument of type aggregator.WithdrawFundsReq");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_WithdrawFundsReq(buffer_arg) {
-      return avs_pb24.WithdrawFundsReq.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.WithdrawFundsReq.deserializeBinary(new Uint8Array(buffer_arg));
     }
     function serialize_aggregator_WithdrawFundsResp(arg) {
-      if (!(arg instanceof avs_pb24.WithdrawFundsResp)) {
+      if (!(arg instanceof avs_pb25.WithdrawFundsResp)) {
         throw new Error("Expected argument of type aggregator.WithdrawFundsResp");
       }
       return Buffer.from(arg.serializeBinary());
     }
     function deserialize_aggregator_WithdrawFundsResp(buffer_arg) {
-      return avs_pb24.WithdrawFundsResp.deserializeBinary(new Uint8Array(buffer_arg));
+      return avs_pb25.WithdrawFundsResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
     var AggregatorService = exports2.AggregatorService = {
       // Exchange for an Auth Key to authenticate in subsequent request
@@ -17828,8 +18300,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetKey",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.GetKeyReq,
-        responseType: avs_pb24.KeyResp,
+        requestType: avs_pb25.GetKeyReq,
+        responseType: avs_pb25.KeyResp,
         requestSerialize: serialize_aggregator_GetKeyReq,
         requestDeserialize: deserialize_aggregator_GetKeyReq,
         responseSerialize: serialize_aggregator_KeyResp,
@@ -17840,8 +18312,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetSignatureFormat",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.GetSignatureFormatReq,
-        responseType: avs_pb24.GetSignatureFormatResp,
+        requestType: avs_pb25.GetSignatureFormatReq,
+        responseType: avs_pb25.GetSignatureFormatResp,
         requestSerialize: serialize_aggregator_GetSignatureFormatReq,
         requestDeserialize: deserialize_aggregator_GetSignatureFormatReq,
         responseSerialize: serialize_aggregator_GetSignatureFormatResp,
@@ -17852,8 +18324,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetNonce",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.NonceRequest,
-        responseType: avs_pb24.NonceResp,
+        requestType: avs_pb25.NonceRequest,
+        responseType: avs_pb25.NonceResp,
         requestSerialize: serialize_aggregator_NonceRequest,
         requestDeserialize: deserialize_aggregator_NonceRequest,
         responseSerialize: serialize_aggregator_NonceResp,
@@ -17863,8 +18335,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetWallet",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.GetWalletReq,
-        responseType: avs_pb24.GetWalletResp,
+        requestType: avs_pb25.GetWalletReq,
+        responseType: avs_pb25.GetWalletResp,
         requestSerialize: serialize_aggregator_GetWalletReq,
         requestDeserialize: deserialize_aggregator_GetWalletReq,
         responseSerialize: serialize_aggregator_GetWalletResp,
@@ -17874,8 +18346,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/SetWallet",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.SetWalletReq,
-        responseType: avs_pb24.GetWalletResp,
+        requestType: avs_pb25.SetWalletReq,
+        responseType: avs_pb25.GetWalletResp,
         requestSerialize: serialize_aggregator_SetWalletReq,
         requestDeserialize: deserialize_aggregator_SetWalletReq,
         responseSerialize: serialize_aggregator_GetWalletResp,
@@ -17885,8 +18357,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListWallets",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.ListWalletReq,
-        responseType: avs_pb24.ListWalletResp,
+        requestType: avs_pb25.ListWalletReq,
+        responseType: avs_pb25.ListWalletResp,
         requestSerialize: serialize_aggregator_ListWalletReq,
         requestDeserialize: deserialize_aggregator_ListWalletReq,
         responseSerialize: serialize_aggregator_ListWalletResp,
@@ -17897,8 +18369,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/WithdrawFunds",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.WithdrawFundsReq,
-        responseType: avs_pb24.WithdrawFundsResp,
+        requestType: avs_pb25.WithdrawFundsReq,
+        responseType: avs_pb25.WithdrawFundsResp,
         requestSerialize: serialize_aggregator_WithdrawFundsReq,
         requestDeserialize: deserialize_aggregator_WithdrawFundsReq,
         responseSerialize: serialize_aggregator_WithdrawFundsResp,
@@ -17909,8 +18381,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CreateTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.CreateTaskReq,
-        responseType: avs_pb24.CreateTaskResp,
+        requestType: avs_pb25.CreateTaskReq,
+        responseType: avs_pb25.CreateTaskResp,
         requestSerialize: serialize_aggregator_CreateTaskReq,
         requestDeserialize: deserialize_aggregator_CreateTaskReq,
         responseSerialize: serialize_aggregator_CreateTaskResp,
@@ -17920,8 +18392,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListTasks",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.ListTasksReq,
-        responseType: avs_pb24.ListTasksResp,
+        requestType: avs_pb25.ListTasksReq,
+        responseType: avs_pb25.ListTasksResp,
         requestSerialize: serialize_aggregator_ListTasksReq,
         requestDeserialize: deserialize_aggregator_ListTasksReq,
         responseSerialize: serialize_aggregator_ListTasksResp,
@@ -17931,8 +18403,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.IdReq,
-        responseType: avs_pb24.Task,
+        requestType: avs_pb25.IdReq,
+        responseType: avs_pb25.Task,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
         responseSerialize: serialize_aggregator_Task,
@@ -17942,8 +18414,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListExecutions",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.ListExecutionsReq,
-        responseType: avs_pb24.ListExecutionsResp,
+        requestType: avs_pb25.ListExecutionsReq,
+        responseType: avs_pb25.ListExecutionsResp,
         requestSerialize: serialize_aggregator_ListExecutionsReq,
         requestDeserialize: deserialize_aggregator_ListExecutionsReq,
         responseSerialize: serialize_aggregator_ListExecutionsResp,
@@ -17953,8 +18425,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecution",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.ExecutionReq,
-        responseType: avs_pb24.Execution,
+        requestType: avs_pb25.ExecutionReq,
+        responseType: avs_pb25.Execution,
         requestSerialize: serialize_aggregator_ExecutionReq,
         requestDeserialize: deserialize_aggregator_ExecutionReq,
         responseSerialize: serialize_aggregator_Execution,
@@ -17964,8 +18436,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecutionStatus",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.ExecutionReq,
-        responseType: avs_pb24.ExecutionStatusResp,
+        requestType: avs_pb25.ExecutionReq,
+        responseType: avs_pb25.ExecutionStatusResp,
         requestSerialize: serialize_aggregator_ExecutionReq,
         requestDeserialize: deserialize_aggregator_ExecutionReq,
         responseSerialize: serialize_aggregator_ExecutionStatusResp,
@@ -17975,8 +18447,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CancelTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.IdReq,
-        responseType: avs_pb24.CancelTaskResp,
+        requestType: avs_pb25.IdReq,
+        responseType: avs_pb25.CancelTaskResp,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
         responseSerialize: serialize_aggregator_CancelTaskResp,
@@ -17986,8 +18458,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/DeleteTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.IdReq,
-        responseType: avs_pb24.DeleteTaskResp,
+        requestType: avs_pb25.IdReq,
+        responseType: avs_pb25.DeleteTaskResp,
         requestSerialize: serialize_aggregator_IdReq,
         requestDeserialize: deserialize_aggregator_IdReq,
         responseSerialize: serialize_aggregator_DeleteTaskResp,
@@ -17997,8 +18469,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/TriggerTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.TriggerTaskReq,
-        responseType: avs_pb24.TriggerTaskResp,
+        requestType: avs_pb25.TriggerTaskReq,
+        responseType: avs_pb25.TriggerTaskResp,
         requestSerialize: serialize_aggregator_TriggerTaskReq,
         requestDeserialize: deserialize_aggregator_TriggerTaskReq,
         responseSerialize: serialize_aggregator_TriggerTaskResp,
@@ -18011,8 +18483,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/CreateSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.CreateOrUpdateSecretReq,
-        responseType: avs_pb24.CreateSecretResp,
+        requestType: avs_pb25.CreateOrUpdateSecretReq,
+        responseType: avs_pb25.CreateSecretResp,
         requestSerialize: serialize_aggregator_CreateOrUpdateSecretReq,
         requestDeserialize: deserialize_aggregator_CreateOrUpdateSecretReq,
         responseSerialize: serialize_aggregator_CreateSecretResp,
@@ -18022,8 +18494,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/DeleteSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.DeleteSecretReq,
-        responseType: avs_pb24.DeleteSecretResp,
+        requestType: avs_pb25.DeleteSecretReq,
+        responseType: avs_pb25.DeleteSecretResp,
         requestSerialize: serialize_aggregator_DeleteSecretReq,
         requestDeserialize: deserialize_aggregator_DeleteSecretReq,
         responseSerialize: serialize_aggregator_DeleteSecretResp,
@@ -18035,8 +18507,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/ListSecrets",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.ListSecretsReq,
-        responseType: avs_pb24.ListSecretsResp,
+        requestType: avs_pb25.ListSecretsReq,
+        responseType: avs_pb25.ListSecretsResp,
         requestSerialize: serialize_aggregator_ListSecretsReq,
         requestDeserialize: deserialize_aggregator_ListSecretsReq,
         responseSerialize: serialize_aggregator_ListSecretsResp,
@@ -18048,8 +18520,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/UpdateSecret",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.CreateOrUpdateSecretReq,
-        responseType: avs_pb24.UpdateSecretResp,
+        requestType: avs_pb25.CreateOrUpdateSecretReq,
+        responseType: avs_pb25.UpdateSecretResp,
         requestSerialize: serialize_aggregator_CreateOrUpdateSecretReq,
         requestDeserialize: deserialize_aggregator_CreateOrUpdateSecretReq,
         responseSerialize: serialize_aggregator_UpdateSecretResp,
@@ -18065,8 +18537,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetWorkflowCount",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.GetWorkflowCountReq,
-        responseType: avs_pb24.GetWorkflowCountResp,
+        requestType: avs_pb25.GetWorkflowCountReq,
+        responseType: avs_pb25.GetWorkflowCountResp,
         requestSerialize: serialize_aggregator_GetWorkflowCountReq,
         requestDeserialize: deserialize_aggregator_GetWorkflowCountReq,
         responseSerialize: serialize_aggregator_GetWorkflowCountResp,
@@ -18080,8 +18552,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecutionCount",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.GetExecutionCountReq,
-        responseType: avs_pb24.GetExecutionCountResp,
+        requestType: avs_pb25.GetExecutionCountReq,
+        responseType: avs_pb25.GetExecutionCountResp,
         requestSerialize: serialize_aggregator_GetExecutionCountReq,
         requestDeserialize: deserialize_aggregator_GetExecutionCountReq,
         responseSerialize: serialize_aggregator_GetExecutionCountResp,
@@ -18094,8 +18566,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetExecutionStats",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.GetExecutionStatsReq,
-        responseType: avs_pb24.GetExecutionStatsResp,
+        requestType: avs_pb25.GetExecutionStatsReq,
+        responseType: avs_pb25.GetExecutionStatsResp,
         requestSerialize: serialize_aggregator_GetExecutionStatsReq,
         requestDeserialize: deserialize_aggregator_GetExecutionStatsReq,
         responseSerialize: serialize_aggregator_GetExecutionStatsResp,
@@ -18106,8 +18578,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/RunNodeWithInputs",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.RunNodeWithInputsReq,
-        responseType: avs_pb24.RunNodeWithInputsResp,
+        requestType: avs_pb25.RunNodeWithInputsReq,
+        responseType: avs_pb25.RunNodeWithInputsResp,
         requestSerialize: serialize_aggregator_RunNodeWithInputsReq,
         requestDeserialize: deserialize_aggregator_RunNodeWithInputsReq,
         responseSerialize: serialize_aggregator_RunNodeWithInputsResp,
@@ -18118,8 +18590,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/RunTrigger",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.RunTriggerReq,
-        responseType: avs_pb24.RunTriggerResp,
+        requestType: avs_pb25.RunTriggerReq,
+        responseType: avs_pb25.RunTriggerResp,
         requestSerialize: serialize_aggregator_RunTriggerReq,
         requestDeserialize: deserialize_aggregator_RunTriggerReq,
         responseSerialize: serialize_aggregator_RunTriggerResp,
@@ -18130,8 +18602,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/SimulateTask",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.SimulateTaskReq,
-        responseType: avs_pb24.Execution,
+        requestType: avs_pb25.SimulateTaskReq,
+        responseType: avs_pb25.Execution,
         requestSerialize: serialize_aggregator_SimulateTaskReq,
         requestDeserialize: deserialize_aggregator_SimulateTaskReq,
         responseSerialize: serialize_aggregator_Execution,
@@ -18142,8 +18614,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/GetTokenMetadata",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.GetTokenMetadataReq,
-        responseType: avs_pb24.GetTokenMetadataResp,
+        requestType: avs_pb25.GetTokenMetadataReq,
+        responseType: avs_pb25.GetTokenMetadataResp,
         requestSerialize: serialize_aggregator_GetTokenMetadataReq,
         requestDeserialize: deserialize_aggregator_GetTokenMetadataReq,
         responseSerialize: serialize_aggregator_GetTokenMetadataResp,
@@ -18156,8 +18628,8 @@ var require_avs_grpc_pb = __commonJS({
         path: "/aggregator.Aggregator/EstimateFees",
         requestStream: false,
         responseStream: false,
-        requestType: avs_pb24.EstimateFeesReq,
-        responseType: avs_pb24.EstimateFeesResp,
+        requestType: avs_pb25.EstimateFeesReq,
+        responseType: avs_pb25.EstimateFeesResp,
         requestSerialize: serialize_aggregator_EstimateFeesReq,
         requestDeserialize: deserialize_aggregator_EstimateFeesReq,
         responseSerialize: serialize_aggregator_EstimateFeesResp,
@@ -18171,6 +18643,7 @@ var require_avs_grpc_pb = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BalanceNode: () => balance_default,
   BlockTrigger: () => block_default,
   BranchNode: () => branch_default,
   Client: () => Client,
@@ -18180,7 +18653,7 @@ __export(index_exports, {
   CustomCodeNode: () => customCode_default,
   ETHTransferNode: () => ethTransfer_default,
   Edge: () => edge_default,
-  ErrorCode: () => import_types21.ErrorCode,
+  ErrorCode: () => import_types22.ErrorCode,
   EventTrigger: () => event_default,
   Execution: () => execution_default,
   FilterNode: () => filter_default,
@@ -18201,11 +18674,11 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_grpc_js = require("@grpc/grpc-js");
 var import_avs_grpc_pb = __toESM(require_avs_grpc_pb());
-var avs_pb23 = __toESM(require_avs_pb());
+var avs_pb24 = __toESM(require_avs_pb());
 
 // src/models/workflow.ts
 var import_lodash3 = __toESM(require("lodash"));
-var avs_pb19 = __toESM(require_avs_pb());
+var avs_pb20 = __toESM(require_avs_pb());
 
 // src/models/edge.ts
 var avs_pb = __toESM(require_avs_pb());
@@ -18551,6 +19024,9 @@ function convertProtobufNodeTypeToSdk(protobufType) {
     case "NODE_TYPE_LOOP":
       return import_types3.NodeType.Loop;
     // "loop"
+    case "NODE_TYPE_BALANCE":
+      return import_types3.NodeType.Balance;
+    // "balance"
     case "NODE_TYPE_UNSPECIFIED":
       return import_types3.NodeType.Unspecified;
     // "unspecified"
@@ -18894,12 +19370,14 @@ var ManualTrigger2 = class _ManualTrigger extends Trigger {
     let actualData = this.data;
     let headers = {};
     let pathParams = {};
+    let lang = import_types6.Lang.JSON;
     if (typeof this.data === "object" && this.data !== null && !Array.isArray(this.data)) {
       const dataObj = this.data;
       if ("data" in dataObj) {
         actualData = dataObj.data;
         headers = dataObj.headers || {};
         pathParams = dataObj.pathParams || {};
+        lang = dataObj.lang || import_types6.Lang.JSON;
       }
     }
     const dataValue = convertInputToProtobuf(actualData);
@@ -18921,6 +19399,8 @@ var ManualTrigger2 = class _ManualTrigger extends Trigger {
         pathParamsMap.set(key, value);
       });
     }
+    const langValue = import_types6.LangConverter.toProtobuf(lang);
+    config.setLang(langValue);
     manualTrigger.setConfig(config);
     trigger.setManual(manualTrigger);
     return trigger;
@@ -18928,6 +19408,7 @@ var ManualTrigger2 = class _ManualTrigger extends Trigger {
   static fromResponse(raw) {
     const obj = raw.toObject();
     let actualData = null;
+    let lang = import_types6.Lang.JSON;
     const manualTrigger = raw.getManual();
     if (manualTrigger) {
       const config = manualTrigger.getConfig();
@@ -18935,10 +19416,12 @@ var ManualTrigger2 = class _ManualTrigger extends Trigger {
         if (config.hasData()) {
           actualData = extractInputFromProtobuf(config.getData());
         }
+        lang = import_types6.LangConverter.fromProtobuf(config.getLang());
       }
     }
     const manualTriggerData = {
-      data: actualData
+      data: actualData,
+      lang
     };
     return new _ManualTrigger({
       ...obj,
@@ -19038,7 +19521,7 @@ var TriggerFactory = class {
 var factory_default = TriggerFactory;
 
 // src/models/node/factory.ts
-var avs_pb18 = __toESM(require_avs_pb());
+var avs_pb19 = __toESM(require_avs_pb());
 var import_lodash2 = __toESM(require("lodash"));
 
 // src/models/node/interface.ts
@@ -19167,17 +19650,25 @@ var CustomCodeNode2 = class _CustomCodeNode extends Node {
   static createProtobufNode(configData) {
     const node = new avs_pb10.CustomCodeNode();
     const config = new avs_pb10.CustomCodeNode.Config();
-    config.setLang(configData.lang);
+    const langValue = import_types10.LangConverter.toProtobuf(configData.lang);
+    config.setLang(langValue);
     config.setSource(configData.source);
     node.setConfig(config);
     return node;
   }
   static fromResponse(raw) {
     const obj = raw.toObject();
-    const rawConfig = raw.getCustomCode().getConfig().toObject();
+    const customCodeNode = raw.getCustomCode();
+    if (!customCodeNode) {
+      throw new Error("CustomCode node data is missing");
+    }
+    const config = customCodeNode.getConfig();
+    if (!config) {
+      throw new Error("CustomCode config is missing");
+    }
     const convertedConfig = {
-      lang: rawConfig.lang,
-      source: rawConfig.source
+      lang: import_types10.LangConverter.fromProtobuf(config.getLang()),
+      source: config.getSource()
     };
     return new _CustomCodeNode({
       ...obj,
@@ -19803,30 +20294,101 @@ var LoopNode2 = class _LoopNode extends Node {
 };
 var loop_default = LoopNode2;
 
-// src/models/node/factory.ts
+// src/models/node/balance.ts
+var avs_pb18 = __toESM(require_avs_pb());
 var import_types18 = require("@avaprotocol/types");
+var BalanceNode2 = class _BalanceNode extends Node {
+  constructor(props) {
+    super({ ...props, type: import_types18.NodeType.Balance, data: props.data });
+  }
+  /**
+   * Create a protobuf BalanceNode from config data
+   * @param configData - The configuration data for the balance node
+   * @returns Configured avs_pb.BalanceNode
+   */
+  static createProtobufNode(configData) {
+    const node = new avs_pb18.BalanceNode();
+    const config = new avs_pb18.BalanceNode.Config();
+    config.setAddress(configData.address);
+    config.setChain(configData.chain);
+    if (configData.includeSpam !== void 0) {
+      config.setIncludeSpam(configData.includeSpam);
+    }
+    if (configData.includeZeroBalances !== void 0) {
+      config.setIncludeZeroBalances(configData.includeZeroBalances);
+    }
+    if (configData.minUsdValue !== void 0) {
+      config.setMinUsdValueCents(Math.round(configData.minUsdValue * 100));
+    }
+    if (configData.tokenAddresses !== void 0 && configData.tokenAddresses.length > 0) {
+      config.setTokenAddressesList(configData.tokenAddresses);
+    }
+    node.setConfig(config);
+    return node;
+  }
+  static fromResponse(raw) {
+    const obj = raw.toObject();
+    const balanceNode = raw.getBalance();
+    const config = balanceNode.getConfig();
+    const protobufData = config.toObject();
+    const data = {
+      address: protobufData.address,
+      chain: protobufData.chain,
+      includeSpam: protobufData.includeSpam,
+      includeZeroBalances: protobufData.includeZeroBalances,
+      minUsdValue: protobufData.minUsdValueCents / 100,
+      tokenAddresses: protobufData.tokenAddressesList
+    };
+    return new _BalanceNode({
+      ...obj,
+      type: import_types18.NodeType.Balance,
+      data
+    });
+  }
+  toRequest() {
+    const request = new avs_pb18.TaskNode();
+    request.setId(this.id);
+    request.setName(this.name);
+    const node = _BalanceNode.createProtobufNode(this.data);
+    request.setBalance(node);
+    return request;
+  }
+  static fromOutputData(outputData) {
+    const balanceOutput = outputData.getBalance();
+    if (!balanceOutput) return null;
+    const dataValue = balanceOutput.getData();
+    const balanceData = dataValue ? convertProtobufValueToJs(dataValue) : [];
+    return balanceData;
+  }
+};
+var balance_default = BalanceNode2;
+
+// src/models/node/factory.ts
+var import_types19 = require("@avaprotocol/types");
 var NodeFactory = class {
   static create(props) {
     switch (props.type) {
-      case import_types18.NodeType.ContractWrite:
+      case import_types19.NodeType.ContractWrite:
         return new contractWrite_default(props);
-      case import_types18.NodeType.RestAPI:
+      case import_types19.NodeType.RestAPI:
         return new restApi_default(props);
-      case import_types18.NodeType.CustomCode:
+      case import_types19.NodeType.CustomCode:
         return new customCode_default(props);
-      case import_types18.NodeType.ContractRead:
+      case import_types19.NodeType.ContractRead:
         return new contractRead_default(props);
-      case import_types18.NodeType.ETHTransfer:
+      case import_types19.NodeType.ETHTransfer:
         return new ethTransfer_default(props);
-      case import_types18.NodeType.GraphQLQuery:
+      case import_types19.NodeType.GraphQLQuery:
         return new graphqlQuery_default(props);
-      case import_types18.NodeType.Branch:
+      case import_types19.NodeType.Branch:
         return new branch_default(props);
-      case import_types18.NodeType.Filter:
+      case import_types19.NodeType.Filter:
         return new filter_default(props);
-      case import_types18.NodeType.Loop:
+      case import_types19.NodeType.Loop:
         return new loop_default(props);
-      case import_types18.NodeType.Unspecified:
+      case import_types19.NodeType.Balance:
+        return new balance_default(props);
+      case import_types19.NodeType.Unspecified:
         throw new Error("Cannot create node with unspecified type");
       default:
         throw new Error(`Unsupported node type: ${props.type}`);
@@ -19855,31 +20417,35 @@ var NodeFactory = class {
         return filter_default.fromResponse(raw);
       case !!raw.getLoop():
         return loop_default.fromResponse(raw);
+      case !!raw.getBalance():
+        return balance_default.fromResponse(raw);
       default:
         throw new Error(`Unsupported node type: ${raw.getName()}`);
     }
   }
   static fromOutputData(outputData) {
     switch (outputData.getOutputDataCase()) {
-      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.REST_API:
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.REST_API:
         return restApi_default.fromOutputData(outputData);
-      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.CUSTOM_CODE:
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.CUSTOM_CODE:
         return customCode_default.fromOutputData(outputData);
-      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.CONTRACT_READ:
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.CONTRACT_READ:
         return contractRead_default.fromOutputData(outputData);
-      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.CONTRACT_WRITE:
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.CONTRACT_WRITE:
         return contractWrite_default.fromOutputData(outputData);
-      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.ETH_TRANSFER:
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.ETH_TRANSFER:
         return ethTransfer_default.fromOutputData(outputData);
-      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.GRAPHQL:
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.GRAPHQL:
         return graphqlQuery_default.fromOutputData(outputData);
-      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.BRANCH:
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.BRANCH:
         return branch_default.fromOutputData(outputData);
-      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.FILTER:
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.FILTER:
         return filter_default.fromOutputData(outputData);
-      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.LOOP:
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.LOOP:
         return loop_default.fromOutputData(outputData);
-      case avs_pb18.RunNodeWithInputsResp.OutputDataCase.OUTPUT_DATA_NOT_SET:
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.BALANCE:
+        return balance_default.fromOutputData(outputData);
+      case avs_pb19.RunNodeWithInputsResp.OutputDataCase.OUTPUT_DATA_NOT_SET:
       default:
         throw new Error(`Unsupported output data case: ${outputData.getOutputDataCase()}`);
     }
@@ -19888,14 +20454,14 @@ var NodeFactory = class {
 var factory_default2 = NodeFactory;
 
 // src/models/workflow.ts
-var import_types19 = require("@avaprotocol/types");
+var import_types20 = require("@avaprotocol/types");
 function convertStatusToString(status2) {
   const conversionMap = {
-    [avs_pb19.TaskStatus.ACTIVE]: import_types19.WorkflowStatus.Active,
-    [avs_pb19.TaskStatus.COMPLETED]: import_types19.WorkflowStatus.Completed,
-    [avs_pb19.TaskStatus.FAILED]: import_types19.WorkflowStatus.Failed,
-    [avs_pb19.TaskStatus.CANCELED]: import_types19.WorkflowStatus.Canceled,
-    [avs_pb19.TaskStatus.EXECUTING]: import_types19.WorkflowStatus.Executing
+    [avs_pb20.TaskStatus.ACTIVE]: import_types20.WorkflowStatus.Active,
+    [avs_pb20.TaskStatus.COMPLETED]: import_types20.WorkflowStatus.Completed,
+    [avs_pb20.TaskStatus.FAILED]: import_types20.WorkflowStatus.Failed,
+    [avs_pb20.TaskStatus.CANCELED]: import_types20.WorkflowStatus.Canceled,
+    [avs_pb20.TaskStatus.EXECUTING]: import_types20.WorkflowStatus.Executing
   };
   return conversionMap[status2];
 }
@@ -20000,7 +20566,7 @@ var Workflow = class _Workflow {
     });
   }
   toRequest() {
-    const request = new avs_pb19.CreateTaskReq();
+    const request = new avs_pb20.CreateTaskReq();
     request.setSmartWalletAddress(this.smartWalletAddress);
     request.setTrigger(this.trigger.toRequest());
     try {
@@ -20074,11 +20640,11 @@ var Workflow = class _Workflow {
 var workflow_default = Workflow;
 
 // src/models/execution.ts
-var avs_pb21 = __toESM(require_avs_pb());
-var import_types20 = require("@avaprotocol/types");
+var avs_pb22 = __toESM(require_avs_pb());
+var import_types21 = require("@avaprotocol/types");
 
 // src/models/step.ts
-var avs_pb20 = __toESM(require_avs_pb());
+var avs_pb21 = __toESM(require_avs_pb());
 var Step = class _Step {
   constructor(props) {
     this.id = props.id;
@@ -20154,34 +20720,36 @@ var Step = class _Step {
   static extractOutputData(step) {
     const outputCase = this.getOutputDataCase(step);
     switch (outputCase) {
-      case avs_pb20.Execution.Step.OutputDataCase.BLOCK_TRIGGER:
+      case avs_pb21.Execution.Step.OutputDataCase.BLOCK_TRIGGER:
         return typeof step.getBlockTrigger === "function" ? step.getBlockTrigger() : step.blockTrigger;
-      case avs_pb20.Execution.Step.OutputDataCase.FIXED_TIME_TRIGGER:
+      case avs_pb21.Execution.Step.OutputDataCase.FIXED_TIME_TRIGGER:
         return typeof step.getFixedTimeTrigger === "function" ? step.getFixedTimeTrigger() : step.fixedTimeTrigger;
-      case avs_pb20.Execution.Step.OutputDataCase.CRON_TRIGGER:
+      case avs_pb21.Execution.Step.OutputDataCase.CRON_TRIGGER:
         return typeof step.getCronTrigger === "function" ? step.getCronTrigger() : step.cronTrigger;
-      case avs_pb20.Execution.Step.OutputDataCase.EVENT_TRIGGER:
+      case avs_pb21.Execution.Step.OutputDataCase.EVENT_TRIGGER:
         return typeof step.getEventTrigger === "function" ? step.getEventTrigger() : step.eventTrigger;
-      case avs_pb20.Execution.Step.OutputDataCase.MANUAL_TRIGGER:
+      case avs_pb21.Execution.Step.OutputDataCase.MANUAL_TRIGGER:
         return typeof step.getManualTrigger === "function" ? step.getManualTrigger() : step.manualTrigger;
-      case avs_pb20.Execution.Step.OutputDataCase.ETH_TRANSFER:
+      case avs_pb21.Execution.Step.OutputDataCase.ETH_TRANSFER:
         return typeof step.getEthTransfer === "function" ? step.getEthTransfer() : step.ethTransfer;
-      case avs_pb20.Execution.Step.OutputDataCase.GRAPHQL:
+      case avs_pb21.Execution.Step.OutputDataCase.GRAPHQL:
         return typeof step.getGraphql === "function" ? step.getGraphql() : step.graphql;
-      case avs_pb20.Execution.Step.OutputDataCase.CONTRACT_READ:
+      case avs_pb21.Execution.Step.OutputDataCase.CONTRACT_READ:
         return typeof step.getContractRead === "function" ? step.getContractRead() : step.contractRead;
-      case avs_pb20.Execution.Step.OutputDataCase.CONTRACT_WRITE:
+      case avs_pb21.Execution.Step.OutputDataCase.CONTRACT_WRITE:
         return typeof step.getContractWrite === "function" ? step.getContractWrite() : step.contractWrite;
-      case avs_pb20.Execution.Step.OutputDataCase.CUSTOM_CODE:
+      case avs_pb21.Execution.Step.OutputDataCase.CUSTOM_CODE:
         return typeof step.getCustomCode === "function" ? step.getCustomCode() : step.customCode;
-      case avs_pb20.Execution.Step.OutputDataCase.REST_API:
+      case avs_pb21.Execution.Step.OutputDataCase.REST_API:
         return typeof step.getRestApi === "function" ? step.getRestApi() : step.restApi;
-      case avs_pb20.Execution.Step.OutputDataCase.BRANCH:
+      case avs_pb21.Execution.Step.OutputDataCase.BRANCH:
         return typeof step.getBranch === "function" ? step.getBranch() : step.branch;
-      case avs_pb20.Execution.Step.OutputDataCase.FILTER:
+      case avs_pb21.Execution.Step.OutputDataCase.FILTER:
         return typeof step.getFilter === "function" ? step.getFilter() : step.filter;
-      case avs_pb20.Execution.Step.OutputDataCase.LOOP:
+      case avs_pb21.Execution.Step.OutputDataCase.LOOP:
         return typeof step.getLoop === "function" ? step.getLoop() : step.loop;
+      case avs_pb21.Execution.Step.OutputDataCase.BALANCE:
+        return typeof step.getBalance === "function" ? step.getBalance() : step.balance;
       default:
         return null;
     }
@@ -20192,29 +20760,30 @@ var Step = class _Step {
     }
     const stepObj = step;
     if (stepObj.blockTrigger)
-      return avs_pb20.Execution.Step.OutputDataCase.BLOCK_TRIGGER;
+      return avs_pb21.Execution.Step.OutputDataCase.BLOCK_TRIGGER;
     if (stepObj.fixedTimeTrigger)
-      return avs_pb20.Execution.Step.OutputDataCase.FIXED_TIME_TRIGGER;
+      return avs_pb21.Execution.Step.OutputDataCase.FIXED_TIME_TRIGGER;
     if (stepObj.cronTrigger)
-      return avs_pb20.Execution.Step.OutputDataCase.CRON_TRIGGER;
+      return avs_pb21.Execution.Step.OutputDataCase.CRON_TRIGGER;
     if (stepObj.eventTrigger)
-      return avs_pb20.Execution.Step.OutputDataCase.EVENT_TRIGGER;
+      return avs_pb21.Execution.Step.OutputDataCase.EVENT_TRIGGER;
     if (stepObj.manualTrigger)
-      return avs_pb20.Execution.Step.OutputDataCase.MANUAL_TRIGGER;
+      return avs_pb21.Execution.Step.OutputDataCase.MANUAL_TRIGGER;
     if (stepObj.ethTransfer)
-      return avs_pb20.Execution.Step.OutputDataCase.ETH_TRANSFER;
-    if (stepObj.graphql) return avs_pb20.Execution.Step.OutputDataCase.GRAPHQL;
+      return avs_pb21.Execution.Step.OutputDataCase.ETH_TRANSFER;
+    if (stepObj.graphql) return avs_pb21.Execution.Step.OutputDataCase.GRAPHQL;
     if (stepObj.contractRead)
-      return avs_pb20.Execution.Step.OutputDataCase.CONTRACT_READ;
+      return avs_pb21.Execution.Step.OutputDataCase.CONTRACT_READ;
     if (stepObj.contractWrite)
-      return avs_pb20.Execution.Step.OutputDataCase.CONTRACT_WRITE;
+      return avs_pb21.Execution.Step.OutputDataCase.CONTRACT_WRITE;
     if (stepObj.customCode)
-      return avs_pb20.Execution.Step.OutputDataCase.CUSTOM_CODE;
-    if (stepObj.restApi) return avs_pb20.Execution.Step.OutputDataCase.REST_API;
-    if (stepObj.branch) return avs_pb20.Execution.Step.OutputDataCase.BRANCH;
-    if (stepObj.filter) return avs_pb20.Execution.Step.OutputDataCase.FILTER;
-    if (stepObj.loop) return avs_pb20.Execution.Step.OutputDataCase.LOOP;
-    return avs_pb20.Execution.Step.OutputDataCase.OUTPUT_DATA_NOT_SET;
+      return avs_pb21.Execution.Step.OutputDataCase.CUSTOM_CODE;
+    if (stepObj.restApi) return avs_pb21.Execution.Step.OutputDataCase.REST_API;
+    if (stepObj.branch) return avs_pb21.Execution.Step.OutputDataCase.BRANCH;
+    if (stepObj.filter) return avs_pb21.Execution.Step.OutputDataCase.FILTER;
+    if (stepObj.loop) return avs_pb21.Execution.Step.OutputDataCase.LOOP;
+    if (stepObj.balance) return avs_pb21.Execution.Step.OutputDataCase.BALANCE;
+    return avs_pb21.Execution.Step.OutputDataCase.OUTPUT_DATA_NOT_SET;
   }
   static fromResponse(step) {
     let configData = void 0;
@@ -20291,17 +20860,17 @@ var step_default = Step;
 // src/models/execution.ts
 function convertProtobufExecutionStatusToTypes(protobufStatus) {
   switch (protobufStatus) {
-    case avs_pb21.ExecutionStatus.EXECUTION_STATUS_PENDING:
-      return import_types20.ExecutionStatus.Pending;
-    case avs_pb21.ExecutionStatus.EXECUTION_STATUS_SUCCESS:
-      return import_types20.ExecutionStatus.Success;
-    case avs_pb21.ExecutionStatus.EXECUTION_STATUS_FAILED:
-      return import_types20.ExecutionStatus.Failed;
-    case avs_pb21.ExecutionStatus.EXECUTION_STATUS_PARTIAL_SUCCESS:
-      return import_types20.ExecutionStatus.PartialSuccess;
-    case avs_pb21.ExecutionStatus.EXECUTION_STATUS_UNSPECIFIED:
+    case avs_pb22.ExecutionStatus.EXECUTION_STATUS_PENDING:
+      return import_types21.ExecutionStatus.Pending;
+    case avs_pb22.ExecutionStatus.EXECUTION_STATUS_SUCCESS:
+      return import_types21.ExecutionStatus.Success;
+    case avs_pb22.ExecutionStatus.EXECUTION_STATUS_FAILED:
+      return import_types21.ExecutionStatus.Failed;
+    case avs_pb22.ExecutionStatus.EXECUTION_STATUS_PARTIAL_SUCCESS:
+      return import_types21.ExecutionStatus.PartialSuccess;
+    case avs_pb22.ExecutionStatus.EXECUTION_STATUS_UNSPECIFIED:
     default:
-      return import_types20.ExecutionStatus.Unspecified;
+      return import_types21.ExecutionStatus.Unspecified;
   }
 }
 var Execution2 = class _Execution {
@@ -20348,7 +20917,7 @@ var Execution2 = class _Execution {
 var execution_default = Execution2;
 
 // src/models/secret.ts
-var avs_pb22 = __toESM(require_avs_pb());
+var avs_pb23 = __toESM(require_avs_pb());
 var Secret = class {
   constructor(props) {
     this.name = props.name;
@@ -20361,7 +20930,7 @@ var Secret = class {
     this.description = props.description;
   }
   toRequest() {
-    const request = new avs_pb22.CreateOrUpdateSecretReq();
+    const request = new avs_pb23.CreateOrUpdateSecretReq();
     request.setName(this.name);
     if (this.secret) {
       request.setSecret(this.secret);
@@ -20378,22 +20947,22 @@ var Secret = class {
 var secret_default = Secret;
 
 // src/index.ts
-var import_types21 = require("@avaprotocol/types");
+var import_types22 = require("@avaprotocol/types");
 var import_avs_pb = __toESM(require_avs_pb());
 var google_protobuf_struct_pb4 = __toESM(require("google-protobuf/google/protobuf/struct_pb"));
 function convertProtobufExecutionStatus(protobufStatus) {
   switch (protobufStatus) {
     case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_PENDING:
-      return import_types21.ExecutionStatus.Pending;
+      return import_types22.ExecutionStatus.Pending;
     case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_SUCCESS:
-      return import_types21.ExecutionStatus.Success;
+      return import_types22.ExecutionStatus.Success;
     case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_FAILED:
-      return import_types21.ExecutionStatus.Failed;
+      return import_types22.ExecutionStatus.Failed;
     case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_PARTIAL_SUCCESS:
-      return import_types21.ExecutionStatus.PartialSuccess;
+      return import_types22.ExecutionStatus.PartialSuccess;
     case import_avs_pb.ExecutionStatus.EXECUTION_STATUS_UNSPECIFIED:
     default:
-      return import_types21.ExecutionStatus.Unspecified;
+      return import_types22.ExecutionStatus.Unspecified;
   }
 }
 var BaseClient = class {
@@ -20436,7 +21005,7 @@ var BaseClient = class {
   sendFastRequest(method, request, options) {
     return this.sendGrpcRequest(method, request, {
       ...options,
-      timeout: import_types21.TimeoutPresets.FAST
+      timeout: import_types22.TimeoutPresets.FAST
     });
   }
   /**
@@ -20449,7 +21018,7 @@ var BaseClient = class {
   sendSlowRequest(method, request, options) {
     return this.sendGrpcRequest(method, request, {
       ...options,
-      timeout: import_types21.TimeoutPresets.SLOW
+      timeout: import_types22.TimeoutPresets.SLOW
     });
   }
   /**
@@ -20462,7 +21031,7 @@ var BaseClient = class {
   sendNoRetryRequest(method, request, options) {
     return this.sendGrpcRequest(method, request, {
       ...options,
-      timeout: import_types21.TimeoutPresets.NO_RETRY
+      timeout: import_types22.TimeoutPresets.NO_RETRY
     });
   }
   /**
@@ -20487,7 +21056,7 @@ var BaseClient = class {
    * @returns {Promise<GetSignatureFormatResponse>} - The response containing the signature format
    */
   async getSignatureFormat(wallet) {
-    const request = new avs_pb23.GetSignatureFormatReq();
+    const request = new avs_pb24.GetSignatureFormatReq();
     request.setWallet(wallet);
     const result = await this.sendGrpcRequest("getSignatureFormat", request);
     return { message: result.getMessage() };
@@ -20502,7 +21071,7 @@ var BaseClient = class {
     message,
     apiKey
   }) {
-    const request = new avs_pb23.GetKeyReq();
+    const request = new avs_pb24.GetKeyReq();
     request.setMessage(message);
     request.setSignature(apiKey);
     const result = await this.sendGrpcRequest("getKey", request);
@@ -20518,7 +21087,7 @@ var BaseClient = class {
     message,
     signature
   }) {
-    const request = new avs_pb23.GetKeyReq();
+    const request = new avs_pb24.GetKeyReq();
     request.setMessage(message);
     request.setSignature(signature);
     const result = await this.sendGrpcRequest(
@@ -20594,7 +21163,7 @@ var BaseClient = class {
             const metadata = new import_grpc_js.Metadata();
             const authKey = options?.authKey || this.authKey;
             if (authKey) {
-              metadata.set(import_types21.AUTH_KEY_HEADER, authKey);
+              metadata.set(import_types22.AUTH_KEY_HEADER, authKey);
             }
             const call = this.rpcClient[method](
               request,
@@ -20654,7 +21223,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<SmartWallet[]>} - The list of SmartWallet objects
    */
   async getWallets(options) {
-    const request = new avs_pb23.ListWalletReq();
+    const request = new avs_pb24.ListWalletReq();
     const result = await this.sendGrpcRequest("listWallets", request, options);
     return result.getItemsList().map((item) => item.toObject());
   }
@@ -20666,7 +21235,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<SmartWallet>} - The added SmartWallet object
    */
   async getWallet({ salt, factoryAddress }, options) {
-    const request = new avs_pb23.GetWalletReq();
+    const request = new avs_pb24.GetWalletReq();
     request.setSalt(salt);
     if (factoryAddress) {
       request.setFactoryAddress(factoryAddress);
@@ -20695,7 +21264,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<SmartWallet>} - The updated SmartWallet object
    */
   async setWallet({ salt, factoryAddress }, { isHidden }, requestOptions) {
-    const request = new avs_pb23.SetWalletReq();
+    const request = new avs_pb24.SetWalletReq();
     request.setSalt(salt);
     if (factoryAddress) {
       request.setFactoryAddress(factoryAddress);
@@ -20732,7 +21301,7 @@ var Client = class extends BaseClient {
     token,
     smartWalletAddress
   }, options) {
-    const request = new avs_pb23.WithdrawFundsReq();
+    const request = new avs_pb24.WithdrawFundsReq();
     request.setRecipientAddress(recipientAddress);
     request.setAmount(amount);
     request.setToken(token);
@@ -20778,7 +21347,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ items: WorkflowProps[]; pageInfo: PageInfo }>} - The list of WorkflowProps objects with nested pagination metadata
    */
   async getWorkflows(addresses, options) {
-    const request = new avs_pb23.ListTasksReq();
+    const request = new avs_pb24.ListTasksReq();
     for (const a of addresses) {
       request.addSmartWalletAddress(a);
     }
@@ -20788,7 +21357,7 @@ var Client = class extends BaseClient {
     if (options?.after) {
       request.setAfter(options.after);
     }
-    request.setLimit(options?.limit || import_types21.DEFAULT_LIMIT);
+    request.setLimit(options?.limit || import_types22.DEFAULT_LIMIT);
     if (options?.includeNodes) {
       request.setIncludeNodes(options.includeNodes);
     }
@@ -20817,7 +21386,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<number>} - The count of workflows
    */
   async getWorkflowCount(addresses, options) {
-    const request = new avs_pb23.GetWorkflowCountReq();
+    const request = new avs_pb24.GetWorkflowCountReq();
     request.setAddressesList(addresses);
     const result = await this.sendGrpcRequest("getWorkflowCount", request, options);
     return result.getTotal();
@@ -20833,7 +21402,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ items: ExecutionProps[]; pageInfo: PageInfo }>} - The list of ExecutionProps objects with nested pagination metadata
    */
   async getExecutions(workflows, options) {
-    const request = new avs_pb23.ListExecutionsReq();
+    const request = new avs_pb24.ListExecutionsReq();
     for (const w of workflows) {
       request.addTaskIds(w);
     }
@@ -20843,7 +21412,7 @@ var Client = class extends BaseClient {
     if (options?.after) {
       request.setAfter(options.after);
     }
-    request.setLimit(options?.limit || import_types21.DEFAULT_LIMIT);
+    request.setLimit(options?.limit || import_types22.DEFAULT_LIMIT);
     const result = await this.sendGrpcRequest("listExecutions", request, options);
     const pageInfo = result.getPageInfo();
     if (!pageInfo) {
@@ -20867,7 +21436,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<ExecutionProps>} - The ExecutionProps object
    */
   async getExecution(workflowId, executionId, options) {
-    const request = new avs_pb23.ExecutionReq();
+    const request = new avs_pb24.ExecutionReq();
     request.setTaskId(workflowId);
     request.setExecutionId(executionId);
     const result = await this.sendGrpcRequest("getExecution", request, options);
@@ -20880,7 +21449,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<number>} - The count of executions
    */
   async getExecutionCount(workflows, options) {
-    const request = new avs_pb23.GetExecutionCountReq();
+    const request = new avs_pb24.GetExecutionCountReq();
     request.setWorkflowIdsList(workflows);
     const result = await this.sendGrpcRequest("getExecutionCount", request, options);
     return result.getTotal();
@@ -20894,7 +21463,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<GetExecutionStatsResponse>} - Execution statistics
    */
   async getExecutionStats(options) {
-    const request = new avs_pb23.GetExecutionStatsReq();
+    const request = new avs_pb24.GetExecutionStatsReq();
     if (options?.workflowIds && options.workflowIds.length > 0) {
       request.setWorkflowIdsList(options.workflowIds);
     }
@@ -20917,7 +21486,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<ExecutionStatus>} - The status of the execution
    */
   async getExecutionStatus(workflowId, executionId, options) {
-    const request = new avs_pb23.ExecutionReq();
+    const request = new avs_pb24.ExecutionReq();
     request.setTaskId(workflowId);
     request.setExecutionId(executionId);
     const result = await this.sendGrpcRequest("getExecutionStatus", request, options);
@@ -20930,7 +21499,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<Workflow>} - The Workflow object
    */
   async getWorkflow(id, options) {
-    const request = new avs_pb23.IdReq();
+    const request = new avs_pb24.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest(
       "getTask",
@@ -20953,14 +21522,14 @@ var Client = class extends BaseClient {
     triggerData,
     isBlocking = false
   }, options) {
-    const request = new avs_pb23.TriggerTaskReq();
+    const request = new avs_pb24.TriggerTaskReq();
     request.setTaskId(id);
-    request.setTriggerType(import_types21.TriggerTypeConverter.toProtobuf(triggerData.type));
+    request.setTriggerType(import_types22.TriggerTypeConverter.toProtobuf(triggerData.type));
     request.setIsBlocking(isBlocking);
     switch (triggerData.type) {
-      case import_types21.TriggerType.FixedTime: {
+      case import_types22.TriggerType.FixedTime: {
         const fixedTimeData = triggerData;
-        const fixedTimeOutput = new avs_pb23.FixedTimeTrigger.Output();
+        const fixedTimeOutput = new avs_pb24.FixedTimeTrigger.Output();
         const triggerOutputData = {
           timestamp: fixedTimeData.timestamp,
           timestampIso: fixedTimeData.timestampIso
@@ -20973,9 +21542,9 @@ var Client = class extends BaseClient {
         request.setFixedTimeTrigger(fixedTimeOutput);
         break;
       }
-      case import_types21.TriggerType.Cron: {
+      case import_types22.TriggerType.Cron: {
         const cronData = triggerData;
-        const cronOutput = new avs_pb23.CronTrigger.Output();
+        const cronOutput = new avs_pb24.CronTrigger.Output();
         const triggerOutputData = {
           timestamp: cronData.timestamp,
           timestampIso: cronData.timestampIso
@@ -20988,9 +21557,9 @@ var Client = class extends BaseClient {
         request.setCronTrigger(cronOutput);
         break;
       }
-      case import_types21.TriggerType.Block: {
+      case import_types22.TriggerType.Block: {
         const blockData = triggerData;
-        const blockOutput = new avs_pb23.BlockTrigger.Output();
+        const blockOutput = new avs_pb24.BlockTrigger.Output();
         const triggerOutputData = {
           blockNumber: blockData.blockNumber,
           blockHash: blockData.blockHash || "",
@@ -21008,9 +21577,9 @@ var Client = class extends BaseClient {
         request.setBlockTrigger(blockOutput);
         break;
       }
-      case import_types21.TriggerType.Event: {
+      case import_types22.TriggerType.Event: {
         const eventData = triggerData;
-        const eventOutput = new avs_pb23.EventTrigger.Output();
+        const eventOutput = new avs_pb24.EventTrigger.Output();
         if (eventData.data) {
           const protobufValue = convertJSValueToProtobuf(eventData.data);
           eventOutput.setData(protobufValue);
@@ -21018,9 +21587,9 @@ var Client = class extends BaseClient {
         request.setEventTrigger(eventOutput);
         break;
       }
-      case import_types21.TriggerType.Manual: {
+      case import_types22.TriggerType.Manual: {
         const manualData = triggerData;
-        const manualOutput = new avs_pb23.ManualTrigger.Output();
+        const manualOutput = new avs_pb24.ManualTrigger.Output();
         if (manualData.data) {
           const protobufValue = convertJSValueToProtobuf(manualData.data);
           manualOutput.setData(protobufValue);
@@ -21028,7 +21597,7 @@ var Client = class extends BaseClient {
         request.setManualTrigger(manualOutput);
         break;
       }
-      case import_types21.TriggerType.Unspecified:
+      case import_types22.TriggerType.Unspecified:
         break;
       default:
         throw new Error(
@@ -21092,7 +21661,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<CancelTaskResponse>} - The response from canceling the workflow
    */
   async cancelWorkflow(id, options) {
-    const request = new avs_pb23.IdReq();
+    const request = new avs_pb24.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest("cancelTask", request, options);
     return {
@@ -21111,7 +21680,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<DeleteTaskResponse>} - The response from deleting the workflow
    */
   async deleteWorkflow(id, options) {
-    const request = new avs_pb23.IdReq();
+    const request = new avs_pb24.IdReq();
     request.setId(id);
     const result = await this.sendGrpcRequest("deleteTask", request, options);
     return {
@@ -21134,7 +21703,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<CreateSecretResponse>} - Structured response with creation details
    */
   async createSecret(name, value, options) {
-    const request = new avs_pb23.CreateOrUpdateSecretReq();
+    const request = new avs_pb24.CreateOrUpdateSecretReq();
     request.setName(name);
     request.setSecret(value);
     if (options?.workflowId) {
@@ -21164,7 +21733,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<UpdateSecretResponse>} - Structured response with update details
    */
   async updateSecret(name, value, options) {
-    const request = new avs_pb23.CreateOrUpdateSecretReq();
+    const request = new avs_pb24.CreateOrUpdateSecretReq();
     request.setName(name);
     request.setSecret(value);
     if (options?.workflowId) {
@@ -21198,7 +21767,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<{ items: SecretProps[]; pageInfo: PageInfo }>} - The list of Secret objects with nested pagination metadata
    */
   async getSecrets(options) {
-    const request = new avs_pb23.ListSecretsReq();
+    const request = new avs_pb24.ListSecretsReq();
     if (options?.workflowId) {
       request.setWorkflowId(options.workflowId);
     }
@@ -21208,7 +21777,7 @@ var Client = class extends BaseClient {
     if (options?.after) {
       request.setAfter(options.after);
     }
-    request.setLimit(options?.limit || import_types21.DEFAULT_LIMIT);
+    request.setLimit(options?.limit || import_types22.DEFAULT_LIMIT);
     if (options?.includeTimestamps) {
       request.setIncludeTimestamps(options.includeTimestamps);
     }
@@ -21253,7 +21822,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<DeleteSecretResponse>} - Structured response with deletion details
    */
   async deleteSecret(name, options) {
-    const request = new avs_pb23.DeleteSecretReq();
+    const request = new avs_pb24.DeleteSecretReq();
     request.setName(name);
     if (options?.workflowId) {
       request.setWorkflowId(options.workflowId);
@@ -21282,22 +21851,22 @@ var Client = class extends BaseClient {
    */
   async runNodeWithInputs({ nodeType, nodeConfig, inputVariables = {} }, options) {
     const triggerTypes = [
-      import_types21.TriggerType.Block,
-      import_types21.TriggerType.FixedTime,
-      import_types21.TriggerType.Cron,
-      import_types21.TriggerType.Event,
-      import_types21.TriggerType.Manual
+      import_types22.TriggerType.Block,
+      import_types22.TriggerType.FixedTime,
+      import_types22.TriggerType.Cron,
+      import_types22.TriggerType.Event,
+      import_types22.TriggerType.Manual
     ];
     if (triggerTypes.includes(nodeType)) {
       return {
         success: false,
         error: `Trigger type "${nodeType}" should use the runTrigger() method instead of runNodeWithInputs()`,
-        errorCode: import_types21.ErrorCode.INVALID_REQUEST,
+        errorCode: import_types22.ErrorCode.INVALID_REQUEST,
         data: null
       };
     }
-    const request = new avs_pb23.RunNodeWithInputsReq();
-    const protobufNodeType = import_types21.NodeTypeGoConverter.fromGoString(nodeType);
+    const request = new avs_pb24.RunNodeWithInputsReq();
+    const protobufNodeType = import_types22.NodeTypeGoConverter.fromGoString(nodeType);
     request.setNodeType(protobufNodeType);
     const nodeConfigMap = request.getNodeConfigMap();
     for (const [key, value] of Object.entries(nodeConfig)) {
@@ -21316,7 +21885,9 @@ var Client = class extends BaseClient {
       error: result.getError(),
       errorCode: result.getErrorCode() || void 0,
       metadata: result.hasMetadata() ? toCamelCaseKeys(convertProtobufValueToJs(result.getMetadata())) : void 0,
-      executionContext: result.hasExecutionContext() ? toCamelCaseKeys(convertProtobufValueToJs(result.getExecutionContext())) : void 0
+      executionContext: result.hasExecutionContext() ? toCamelCaseKeys(
+        convertProtobufValueToJs(result.getExecutionContext())
+      ) : void 0
     };
   }
   /**
@@ -21328,8 +21899,8 @@ var Client = class extends BaseClient {
    * @returns {Promise<RunTriggerResponse>} - The response from running the trigger
    */
   async runTrigger({ triggerType, triggerConfig }, options) {
-    const request = new avs_pb23.RunTriggerReq();
-    const protobufTriggerType = import_types21.TriggerTypeGoConverter.fromGoString(triggerType);
+    const request = new avs_pb24.RunTriggerReq();
+    const protobufTriggerType = import_types22.TriggerTypeGoConverter.fromGoString(triggerType);
     request.setTriggerType(protobufTriggerType);
     const triggerConfigMap = request.getTriggerConfigMap();
     for (const [key, value] of Object.entries(triggerConfig)) {
@@ -21352,7 +21923,9 @@ var Client = class extends BaseClient {
       error: result.getError(),
       errorCode: result.getErrorCode() || void 0,
       metadata: toCamelCaseKeys(metadata),
-      executionContext: result.hasExecutionContext() ? toCamelCaseKeys(convertProtobufValueToJs(result.getExecutionContext())) : void 0
+      executionContext: result.hasExecutionContext() ? toCamelCaseKeys(
+        convertProtobufValueToJs(result.getExecutionContext())
+      ) : void 0
     };
   }
   /**
@@ -21366,7 +21939,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<ExecutionProps>} - The response from simulating the task
    */
   async simulateWorkflow({ trigger, nodes, edges, inputVariables = {} }, options) {
-    const request = new avs_pb23.SimulateTaskReq();
+    const request = new avs_pb24.SimulateTaskReq();
     const triggerSdk = factory_default.create(trigger);
     request.setTrigger(triggerSdk.toRequest());
     const nodeMessages = nodes.map((node) => {
@@ -21395,7 +21968,7 @@ var Client = class extends BaseClient {
    * @returns {Promise<GetTokenMetadataResponse>} - The response containing token metadata
    */
   async getTokenMetadata({ address }, options) {
-    const request = new avs_pb23.GetTokenMetadataReq();
+    const request = new avs_pb24.GetTokenMetadataReq();
     request.setAddress(address);
     const result = await this.sendGrpcRequest("getTokenMetadata", request, options);
     const token = result.getToken();
@@ -21412,7 +21985,7 @@ var Client = class extends BaseClient {
   }
   /**
    * Get comprehensive fee estimation for workflow deployment
-   * 
+   *
    * @param params - Fee estimation request parameters
    * @param options - Optional request options (auth key, timeout)
    * @returns Promise resolving to comprehensive fee breakdown
@@ -21425,7 +21998,7 @@ var Client = class extends BaseClient {
     createdAt,
     expireAt
   }, options) {
-    const request = new avs_pb23.EstimateFeesReq();
+    const request = new avs_pb24.EstimateFeesReq();
     const triggerSdk = factory_default.create(trigger);
     request.setTrigger(triggerSdk.toRequest());
     const nodeMessages = nodes.map((node) => {
@@ -21509,7 +22082,9 @@ var Client = class extends BaseClient {
       response.totalFees = this.convertFeeAmount(result.getTotalFees());
     }
     if (result.getTotalDiscounts()) {
-      response.totalDiscounts = this.convertFeeAmount(result.getTotalDiscounts());
+      response.totalDiscounts = this.convertFeeAmount(
+        result.getTotalDiscounts()
+      );
     }
     if (result.getFinalTotal()) {
       response.finalTotal = this.convertFeeAmount(result.getFinalTotal());
@@ -21578,6 +22153,7 @@ var Client = class extends BaseClient {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BalanceNode,
   BlockTrigger,
   BranchNode,
   Client,