@avaprotocol/sdk-js 1.7.0 → 2.0.1

package/dist/index.mjs

@@ -112,6 +112,8 @@ var require_avs_pb = __commonJS({
     goog.exportSymbol("proto.aggregator.GetKeyReq", null, global);
     goog.exportSymbol("proto.aggregator.GetSignatureFormatReq", null, global);
     goog.exportSymbol("proto.aggregator.GetSignatureFormatResp", null, global);
+    goog.exportSymbol("proto.aggregator.GetTokenMetadataReq", null, global);
+    goog.exportSymbol("proto.aggregator.GetTokenMetadataResp", null, global);
     goog.exportSymbol("proto.aggregator.GetWalletReq", null, global);
     goog.exportSymbol("proto.aggregator.GetWalletResp", null, global);
     goog.exportSymbol("proto.aggregator.GetWorkflowCountReq", null, global);
@@ -161,10 +163,32 @@ var require_avs_pb = __commonJS({
     goog.exportSymbol("proto.aggregator.TaskStatus", null, global);
     goog.exportSymbol("proto.aggregator.TaskTrigger", null, global);
     goog.exportSymbol("proto.aggregator.TaskTrigger.TriggerTypeCase", null, global);
+    goog.exportSymbol("proto.aggregator.TokenMetadata", null, global);
     goog.exportSymbol("proto.aggregator.TriggerTaskReq", null, global);
     goog.exportSymbol("proto.aggregator.TriggerTaskReq.TriggerOutputCase", null, global);
     goog.exportSymbol("proto.aggregator.TriggerTaskResp", null, global);
     goog.exportSymbol("proto.aggregator.TriggerType", null, global);
+    proto.aggregator.TokenMetadata = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.TokenMetadata, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.TokenMetadata.displayName = "proto.aggregator.TokenMetadata";
+    }
+    proto.aggregator.GetTokenMetadataReq = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.GetTokenMetadataReq, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.GetTokenMetadataReq.displayName = "proto.aggregator.GetTokenMetadataReq";
+    }
+    proto.aggregator.GetTokenMetadataResp = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.GetTokenMetadataResp, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.GetTokenMetadataResp.displayName = "proto.aggregator.GetTokenMetadataResp";
+    }
     proto.aggregator.IdReq = function(opt_data) {
       jspb.Message.initialize(this, opt_data, 0, -1, null, null);
     };
@@ -830,6 +854,323 @@ var require_avs_pb = __commonJS({
     if (goog.DEBUG && !COMPILED) {
       proto.aggregator.SimulateTaskReq.displayName = "proto.aggregator.SimulateTaskReq";
     }
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.TokenMetadata.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.TokenMetadata.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.TokenMetadata.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          address: jspb.Message.getFieldWithDefault(msg, 1, ""),
+          name: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          symbol: jspb.Message.getFieldWithDefault(msg, 3, ""),
+          decimals: jspb.Message.getFieldWithDefault(msg, 4, 0)
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.TokenMetadata.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.TokenMetadata();
+      return proto.aggregator.TokenMetadata.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.TokenMetadata.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.setName(value);
+            break;
+          case 3:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setSymbol(value);
+            break;
+          case 4:
+            var value = (
+              /** @type {number} */
+              reader.readUint32()
+            );
+            msg.setDecimals(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.TokenMetadata.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.TokenMetadata.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.TokenMetadata.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getAddress();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
+      }
+      f = message.getName();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
+      }
+      f = message.getSymbol();
+      if (f.length > 0) {
+        writer.writeString(
+          3,
+          f
+        );
+      }
+      f = message.getDecimals();
+      if (f !== 0) {
+        writer.writeUint32(
+          4,
+          f
+        );
+      }
+    };
+    proto.aggregator.TokenMetadata.prototype.getAddress = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.TokenMetadata.prototype.setAddress = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    proto.aggregator.TokenMetadata.prototype.getName = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
+      );
+    };
+    proto.aggregator.TokenMetadata.prototype.setName = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
+    };
+    proto.aggregator.TokenMetadata.prototype.getSymbol = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 3, "")
+      );
+    };
+    proto.aggregator.TokenMetadata.prototype.setSymbol = function(value) {
+      return jspb.Message.setProto3StringField(this, 3, value);
+    };
+    proto.aggregator.TokenMetadata.prototype.getDecimals = function() {
+      return (
+        /** @type {number} */
+        jspb.Message.getFieldWithDefault(this, 4, 0)
+      );
+    };
+    proto.aggregator.TokenMetadata.prototype.setDecimals = function(value) {
+      return jspb.Message.setProto3IntField(this, 4, value);
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.GetTokenMetadataReq.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.GetTokenMetadataReq.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.GetTokenMetadataReq.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          address: jspb.Message.getFieldWithDefault(msg, 1, "")
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.GetTokenMetadataReq.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.GetTokenMetadataReq();
+      return proto.aggregator.GetTokenMetadataReq.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.GetTokenMetadataReq.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;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.GetTokenMetadataReq.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.GetTokenMetadataReq.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.GetTokenMetadataReq.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getAddress();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
+      }
+    };
+    proto.aggregator.GetTokenMetadataReq.prototype.getAddress = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.GetTokenMetadataReq.prototype.setAddress = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.GetTokenMetadataResp.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.GetTokenMetadataResp.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.GetTokenMetadataResp.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          token: (f = msg.getToken()) && proto.aggregator.TokenMetadata.toObject(includeInstance, f),
+          found: jspb.Message.getBooleanFieldWithDefault(msg, 2, false),
+          source: jspb.Message.getFieldWithDefault(msg, 3, "")
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.GetTokenMetadataResp.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.GetTokenMetadataResp();
+      return proto.aggregator.GetTokenMetadataResp.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.GetTokenMetadataResp.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = new proto.aggregator.TokenMetadata();
+            reader.readMessage(value, proto.aggregator.TokenMetadata.deserializeBinaryFromReader);
+            msg.setToken(value);
+            break;
+          case 2:
+            var value = (
+              /** @type {boolean} */
+              reader.readBool()
+            );
+            msg.setFound(value);
+            break;
+          case 3:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setSource(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.GetTokenMetadataResp.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.GetTokenMetadataResp.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.GetTokenMetadataResp.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getToken();
+      if (f != null) {
+        writer.writeMessage(
+          1,
+          f,
+          proto.aggregator.TokenMetadata.serializeBinaryToWriter
+        );
+      }
+      f = message.getFound();
+      if (f) {
+        writer.writeBool(
+          2,
+          f
+        );
+      }
+      f = message.getSource();
+      if (f.length > 0) {
+        writer.writeString(
+          3,
+          f
+        );
+      }
+    };
+    proto.aggregator.GetTokenMetadataResp.prototype.getToken = function() {
+      return (
+        /** @type{?proto.aggregator.TokenMetadata} */
+        jspb.Message.getWrapperField(this, proto.aggregator.TokenMetadata, 1)
+      );
+    };
+    proto.aggregator.GetTokenMetadataResp.prototype.setToken = function(value) {
+      return jspb.Message.setWrapperField(this, 1, value);
+    };
+    proto.aggregator.GetTokenMetadataResp.prototype.clearToken = function() {
+      return this.setToken(void 0);
+    };
+    proto.aggregator.GetTokenMetadataResp.prototype.hasToken = function() {
+      return jspb.Message.getField(this, 1) != null;
+    };
+    proto.aggregator.GetTokenMetadataResp.prototype.getFound = function() {
+      return (
+        /** @type {boolean} */
+        jspb.Message.getBooleanFieldWithDefault(this, 2, false)
+      );
+    };
+    proto.aggregator.GetTokenMetadataResp.prototype.setFound = function(value) {
+      return jspb.Message.setProto3BooleanField(this, 2, value);
+    };
+    proto.aggregator.GetTokenMetadataResp.prototype.getSource = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 3, "")
+      );
+    };
+    proto.aggregator.GetTokenMetadataResp.prototype.setSource = function(value) {
+      return jspb.Message.setProto3StringField(this, 3, value);
+    };
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.IdReq.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.IdReq.toObject(opt_includeInstance, this);
@@ -13138,8 +13479,6 @@ var require_avs_pb = __commonJS({
             proto.aggregator.TaskEdge.toObject,
             includeInstance
           ),
-          triggerType: jspb.Message.getFieldWithDefault(msg, 4, 0),
-          triggerConfigMap: (f = msg.getTriggerConfigMap()) ? f.toObject(includeInstance, proto.google.protobuf.Value.toObject) : [],
           inputVariablesMap: (f = msg.getInputVariablesMap()) ? f.toObject(includeInstance, proto.google.protobuf.Value.toObject) : []
         };
         if (includeInstance) {
@@ -13175,19 +13514,6 @@ var require_avs_pb = __commonJS({
             reader.readMessage(value, proto.aggregator.TaskEdge.deserializeBinaryFromReader);
             msg.addEdges(value);
             break;
-          case 4:
-            var value = (
-              /** @type {!proto.aggregator.TriggerType} */
-              reader.readEnum()
-            );
-            msg.setTriggerType(value);
-            break;
-          case 5:
-            var value = msg.getTriggerConfigMap();
-            reader.readMessage(value, function(message, reader2) {
-              jspb.Map.deserializeBinary(message, reader2, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.google.protobuf.Value.deserializeBinaryFromReader, "", new proto.google.protobuf.Value());
-            });
-            break;
           case 6:
             var value = msg.getInputVariablesMap();
             reader.readMessage(value, function(message, reader2) {
@@ -13232,17 +13558,6 @@ var require_avs_pb = __commonJS({
           proto.aggregator.TaskEdge.serializeBinaryToWriter
         );
       }
-      f = message.getTriggerType();
-      if (f !== 0) {
-        writer.writeEnum(
-          4,
-          f
-        );
-      }
-      f = message.getTriggerConfigMap(true);
-      if (f && f.getLength() > 0) {
-        f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.google.protobuf.Value.serializeBinaryToWriter);
-      }
       f = message.getInputVariablesMap(true);
       if (f && f.getLength() > 0) {
         f.serializeBinary(6, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.google.protobuf.Value.serializeBinaryToWriter);
@@ -13293,30 +13608,6 @@ var require_avs_pb = __commonJS({
     proto.aggregator.SimulateTaskReq.prototype.clearEdgesList = function() {
       return this.setEdgesList([]);
     };
-    proto.aggregator.SimulateTaskReq.prototype.getTriggerType = function() {
-      return (
-        /** @type {!proto.aggregator.TriggerType} */
-        jspb.Message.getFieldWithDefault(this, 4, 0)
-      );
-    };
-    proto.aggregator.SimulateTaskReq.prototype.setTriggerType = function(value) {
-      return jspb.Message.setProto3EnumField(this, 4, value);
-    };
-    proto.aggregator.SimulateTaskReq.prototype.getTriggerConfigMap = function(opt_noLazyCreate) {
-      return (
-        /** @type {!jspb.Map<string,!proto.google.protobuf.Value>} */
-        jspb.Message.getMapField(
-          this,
-          5,
-          opt_noLazyCreate,
-          proto.google.protobuf.Value
-        )
-      );
-    };
-    proto.aggregator.SimulateTaskReq.prototype.clearTriggerConfigMap = function() {
-      this.getTriggerConfigMap().clear();
-      return this;
-    };
     proto.aggregator.SimulateTaskReq.prototype.getInputVariablesMap = function(opt_noLazyCreate) {
       return (
         /** @type {!jspb.Map<string,!proto.google.protobuf.Value>} */
@@ -13518,6 +13809,24 @@ var require_avs_grpc_pb = __commonJS({
     function deserialize_aggregator_GetSignatureFormatResp(buffer_arg) {
       return avs_pb23.GetSignatureFormatResp.deserializeBinary(new Uint8Array(buffer_arg));
     }
+    function serialize_aggregator_GetTokenMetadataReq(arg) {
+      if (!(arg instanceof avs_pb23.GetTokenMetadataReq)) {
+        throw new Error("Expected argument of type aggregator.GetTokenMetadataReq");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
+    function deserialize_aggregator_GetTokenMetadataReq(buffer_arg) {
+      return avs_pb23.GetTokenMetadataReq.deserializeBinary(new Uint8Array(buffer_arg));
+    }
+    function serialize_aggregator_GetTokenMetadataResp(arg) {
+      if (!(arg instanceof avs_pb23.GetTokenMetadataResp)) {
+        throw new Error("Expected argument of type aggregator.GetTokenMetadataResp");
+      }
+      return Buffer.from(arg.serializeBinary());
+    }
+    function deserialize_aggregator_GetTokenMetadataResp(buffer_arg) {
+      return avs_pb23.GetTokenMetadataResp.deserializeBinary(new Uint8Array(buffer_arg));
+    }
     function serialize_aggregator_GetWalletReq(arg) {
       if (!(arg instanceof avs_pb23.GetWalletReq)) {
         throw new Error("Expected argument of type aggregator.GetWalletReq");
@@ -14054,6 +14363,18 @@ var require_avs_grpc_pb = __commonJS({
         requestDeserialize: deserialize_aggregator_SimulateTaskReq,
         responseSerialize: serialize_aggregator_Execution,
         responseDeserialize: deserialize_aggregator_Execution
+      },
+      // GetTokenMetadata allows looking up ERC20 token metadata by contract address
+      getTokenMetadata: {
+        path: "/aggregator.Aggregator/GetTokenMetadata",
+        requestStream: false,
+        responseStream: false,
+        requestType: avs_pb23.GetTokenMetadataReq,
+        responseType: avs_pb23.GetTokenMetadataResp,
+        requestSerialize: serialize_aggregator_GetTokenMetadataReq,
+        requestDeserialize: deserialize_aggregator_GetTokenMetadataReq,
+        responseSerialize: serialize_aggregator_GetTokenMetadataResp,
+        responseDeserialize: deserialize_aggregator_GetTokenMetadataResp
       }
     };
     exports.AggregatorClient = grpc.makeGenericClientConstructor(AggregatorService, "Aggregator");
@@ -14119,15 +14440,16 @@ var Trigger = class {
 var interface_default = Trigger;
 
 // src/models/trigger/block.ts
-import { TriggerType } from "@avaprotocol/types";
+import { TriggerType as TriggerType2 } from "@avaprotocol/types";
 var BlockTrigger2 = class _BlockTrigger extends interface_default {
   constructor(props) {
-    super({ ...props, type: TriggerType.Block, data: props.data });
+    super({ ...props, type: TriggerType2.Block, data: props.data });
   }
   toRequest() {
     const request = new avs_pb2.TaskTrigger();
     request.setName(this.name);
     request.setId(this.id);
+    request.setType(avs_pb2.TriggerType.TRIGGER_TYPE_BLOCK);
     if (!this.data) {
       throw new Error(`Trigger data is missing for ${this.type}`);
     }
@@ -14151,7 +14473,7 @@ var BlockTrigger2 = class _BlockTrigger extends interface_default {
     }
     return new _BlockTrigger({
       ...obj,
-      type: TriggerType.Block,
+      type: TriggerType2.Block,
       data
     });
   }
@@ -14177,15 +14499,16 @@ var block_default = BlockTrigger2;
 
 // src/models/trigger/cron.ts
 var avs_pb3 = __toESM(require_avs_pb());
-import { TriggerType as TriggerType2 } from "@avaprotocol/types";
+import { TriggerType as TriggerType4 } from "@avaprotocol/types";
 var CronTrigger2 = class _CronTrigger extends interface_default {
   constructor(props) {
-    super({ ...props, type: TriggerType2.Cron, data: props.data });
+    super({ ...props, type: TriggerType4.Cron, data: props.data });
   }
   toRequest() {
     const request = new avs_pb3.TaskTrigger();
     request.setName(this.name);
     request.setId(this.id);
+    request.setType(avs_pb3.TriggerType.TRIGGER_TYPE_CRON);
     if (!this.data) {
       throw new Error(`Trigger data is missing for ${this.type}`);
     }
@@ -14209,7 +14532,7 @@ var CronTrigger2 = class _CronTrigger extends interface_default {
     }
     return new _CronTrigger({
       ...obj,
-      type: TriggerType2.Cron,
+      type: TriggerType4.Cron,
       data
     });
   }
@@ -14242,15 +14565,16 @@ var cron_default = CronTrigger2;
 // src/models/trigger/event.ts
 var avs_pb4 = __toESM(require_avs_pb());
 import * as _ from "lodash";
-import { TriggerType as TriggerType3 } from "@avaprotocol/types";
+import { TriggerType as TriggerType6 } from "@avaprotocol/types";
 var EventTrigger2 = class _EventTrigger extends interface_default {
   constructor(props) {
-    super({ ...props, type: TriggerType3.Event, data: props.data });
+    super({ ...props, type: TriggerType6.Event, data: props.data });
   }
   toRequest() {
     const request = new avs_pb4.TaskTrigger();
     request.setName(this.name);
     request.setId(this.id);
+    request.setType(avs_pb4.TriggerType.TRIGGER_TYPE_EVENT);
     if (!this.data) {
       throw new Error(`Trigger data is missing for ${this.type}`);
     }
@@ -14298,7 +14622,7 @@ var EventTrigger2 = class _EventTrigger extends interface_default {
     }
     return new _EventTrigger({
       ...obj,
-      type: TriggerType3.Event,
+      type: TriggerType6.Event,
       data
     });
   }
@@ -14324,15 +14648,16 @@ var event_default = EventTrigger2;
 
 // src/models/trigger/fixedTime.ts
 var avs_pb5 = __toESM(require_avs_pb());
-import { TriggerType as TriggerType4 } from "@avaprotocol/types";
+import { TriggerType as TriggerType8 } from "@avaprotocol/types";
 var FixedTimeTrigger2 = class _FixedTimeTrigger extends interface_default {
   constructor(props) {
-    super({ ...props, type: TriggerType4.FixedTime, data: props.data });
+    super({ ...props, type: TriggerType8.FixedTime, data: props.data });
   }
   toRequest() {
     const request = new avs_pb5.TaskTrigger();
     request.setName(this.name);
     request.setId(this.id);
+    request.setType(avs_pb5.TriggerType.TRIGGER_TYPE_FIXED_TIME);
     if (!this.data) {
       throw new Error(`Trigger data is missing for ${this.type}`);
     }
@@ -14356,7 +14681,7 @@ var FixedTimeTrigger2 = class _FixedTimeTrigger extends interface_default {
     }
     return new _FixedTimeTrigger({
       ...obj,
-      type: TriggerType4.FixedTime,
+      type: TriggerType8.FixedTime,
       data
     });
   }
@@ -14388,15 +14713,16 @@ var fixedTime_default = FixedTimeTrigger2;
 
 // src/models/trigger/manual.ts
 var avs_pb6 = __toESM(require_avs_pb());
-import { TriggerType as TriggerType5 } from "@avaprotocol/types";
+import { TriggerType as TriggerType10 } from "@avaprotocol/types";
 var ManualTrigger = class _ManualTrigger extends interface_default {
   constructor(props) {
-    super({ ...props, type: TriggerType5.Manual, data: props.data || null });
+    super({ ...props, type: TriggerType10.Manual, data: props.data || null });
   }
   toRequest() {
     const trigger = new avs_pb6.TaskTrigger();
     trigger.setId(this.id);
     trigger.setName(this.name);
+    trigger.setType(avs_pb6.TriggerType.TRIGGER_TYPE_MANUAL);
     trigger.setManual(true);
     return trigger;
   }
@@ -14404,7 +14730,7 @@ var ManualTrigger = class _ManualTrigger extends interface_default {
     const obj = raw.toObject();
     return new _ManualTrigger({
       ...obj,
-      type: TriggerType5.Manual,
+      type: TriggerType10.Manual,
       data: null
       // Manual triggers don't have data in the protobuf response
     });
@@ -14433,7 +14759,9 @@ var ManualTrigger = class _ManualTrigger extends interface_default {
 var manual_default = ManualTrigger;
 
 // src/models/trigger/factory.ts
-import { TriggerType as TriggerType7 } from "@avaprotocol/types";
+import {
+  TriggerType as TriggerType12
+} from "@avaprotocol/types";
 
 // src/utils.ts
 import {
@@ -14441,7 +14769,7 @@ import {
   Struct as ProtobufStruct,
   ListValue as ProtobufListValue
 } from "google-protobuf/google/protobuf/struct_pb";
-import { TriggerType as TriggerType6, NodeType } from "@avaprotocol/types";
+import { TriggerType as TriggerType11, NodeType } from "@avaprotocol/types";
 function convertProtobufValueToJs(value) {
   if (!value) {
     return void 0;
@@ -14505,22 +14833,22 @@ function convertJSValueToProtobuf(value) {
 function convertProtobufTriggerTypeToSdk(protobufType) {
   switch (protobufType) {
     case "TRIGGER_TYPE_MANUAL":
-      return TriggerType6.Manual;
+      return TriggerType11.Manual;
     // "manualTrigger"
     case "TRIGGER_TYPE_FIXED_TIME":
-      return TriggerType6.FixedTime;
+      return TriggerType11.FixedTime;
     // "fixedTimeTrigger"
     case "TRIGGER_TYPE_CRON":
-      return TriggerType6.Cron;
+      return TriggerType11.Cron;
     // "cronTrigger"
     case "TRIGGER_TYPE_BLOCK":
-      return TriggerType6.Block;
+      return TriggerType11.Block;
     // "blockTrigger"
     case "TRIGGER_TYPE_EVENT":
-      return TriggerType6.Event;
+      return TriggerType11.Event;
     // "eventTrigger"
     case "TRIGGER_TYPE_UNSPECIFIED":
-      return TriggerType6.Unspecified;
+      return TriggerType11.Unspecified;
     // "unspecified"
     default:
       console.warn(`Unknown trigger type: ${protobufType}, using raw value`);
@@ -14584,15 +14912,15 @@ var TriggerFactory = class {
    */
   static create(props) {
     switch (props.type) {
-      case TriggerType7.Block:
+      case TriggerType12.Block:
         return new block_default(props);
-      case TriggerType7.Cron:
+      case TriggerType12.Cron:
         return new cron_default(props);
-      case TriggerType7.Event:
+      case TriggerType12.Event:
         return new event_default(props);
-      case TriggerType7.FixedTime:
+      case TriggerType12.FixedTime:
         return new fixedTime_default(props);
-      case TriggerType7.Manual:
+      case TriggerType12.Manual:
         return new manual_default(props);
     }
     throw new Error("Unsupported trigger type");
@@ -15015,6 +15343,7 @@ var LoopNode2 = class _LoopNode extends interface_default2 {
     super({ ...props, type: NodeType11.Loop, data: props.data });
   }
   static fromResponse(raw) {
+    const obj = raw.toObject();
     const loopNode = raw.getLoop();
     if (!loopNode) {
       throw new Error("Response does not contain a Loop node");
@@ -15032,8 +15361,7 @@ var LoopNode2 = class _LoopNode extends interface_default2 {
       graphqlDataQuery: loopNodeData.graphqlDataQuery
     };
     return new _LoopNode({
-      id: raw.getId(),
-      name: raw.getName(),
+      ...obj,
       type: NodeType11.Loop,
       data
     });
@@ -15505,12 +15833,13 @@ var secret_default = Secret;
 
 // src/index.ts
 import {
-  TriggerType as TriggerType8,
+  TriggerType as TriggerType13,
   NodeTypeGoConverter as NodeTypeGoConverter2,
   TriggerTypeGoConverter,
-  TriggerTypeConverter
+  TriggerTypeConverter,
+  AUTH_KEY_HEADER,
+  DEFAULT_LIMIT
 } from "@avaprotocol/types";
-import { AUTH_KEY_HEADER, DEFAULT_LIMIT } from "@avaprotocol/types";
 var BaseClient = class {
   constructor(opts) {
     this.endpoint = opts.endpoint;
@@ -15895,34 +16224,36 @@ var Client = class extends BaseClient {
     request.setTriggerType(TriggerTypeConverter.toProtobuf(triggerData.type));
     request.setIsBlocking(isBlocking);
     switch (triggerData.type) {
-      case TriggerType8.FixedTime: {
+      case TriggerType13.FixedTime: {
         const fixedTimeOutput = new avs_pb22.FixedTimeTrigger.Output();
         fixedTimeOutput.setTimestamp(triggerData.timestamp);
         fixedTimeOutput.setTimestampIso(triggerData.timestampIso);
         request.setFixedTimeTrigger(fixedTimeOutput);
         break;
       }
-      case TriggerType8.Cron: {
+      case TriggerType13.Cron: {
         const cronOutput = new avs_pb22.CronTrigger.Output();
         cronOutput.setTimestamp(triggerData.timestamp);
         cronOutput.setTimestampIso(triggerData.timestampIso);
         request.setCronTrigger(cronOutput);
         break;
       }
-      case TriggerType8.Block: {
+      case TriggerType13.Block: {
         const blockData = triggerData;
         const blockOutput = new avs_pb22.BlockTrigger.Output();
         blockOutput.setBlockNumber(blockData.blockNumber);
         if (blockData.blockHash) blockOutput.setBlockHash(blockData.blockHash);
         if (blockData.timestamp) blockOutput.setTimestamp(blockData.timestamp);
-        if (blockData.parentHash) blockOutput.setParentHash(blockData.parentHash);
-        if (blockData.difficulty) blockOutput.setDifficulty(blockData.difficulty);
+        if (blockData.parentHash)
+          blockOutput.setParentHash(blockData.parentHash);
+        if (blockData.difficulty)
+          blockOutput.setDifficulty(blockData.difficulty);
         if (blockData.gasLimit) blockOutput.setGasLimit(blockData.gasLimit);
         if (blockData.gasUsed) blockOutput.setGasUsed(blockData.gasUsed);
         request.setBlockTrigger(blockOutput);
         break;
       }
-      case TriggerType8.Event: {
+      case TriggerType13.Event: {
         const eventData = triggerData;
         const eventOutput = new avs_pb22.EventTrigger.Output();
         if (eventData.evmLog) {
@@ -15946,24 +16277,28 @@ var Client = class extends BaseClient {
           transferLog.setToAddress(eventData.transferLog.toAddress);
           transferLog.setValue(eventData.transferLog.value);
           transferLog.setValueFormatted(eventData.transferLog.valueFormatted);
-          transferLog.setTransactionIndex(eventData.transferLog.transactionIndex);
+          transferLog.setTransactionIndex(
+            eventData.transferLog.transactionIndex
+          );
           transferLog.setLogIndex(eventData.transferLog.logIndex);
           eventOutput.setTransferLog(transferLog);
         }
         request.setEventTrigger(eventOutput);
         break;
       }
-      case TriggerType8.Manual: {
+      case TriggerType13.Manual: {
         const manualData = triggerData;
         const manualOutput = new avs_pb22.ManualTrigger.Output();
         if (manualData.runAt) manualOutput.setRunAt(manualData.runAt);
         request.setManualTrigger(manualOutput);
         break;
       }
-      case TriggerType8.Unspecified:
+      case TriggerType13.Unspecified:
         break;
       default:
-        throw new Error(`Unsupported trigger type: ${triggerData.type}`);
+        throw new Error(
+          `Unsupported trigger type: ${triggerData.type}`
+        );
     }
     const result = await this.sendGrpcRequest("triggerTask", request, options);
     return result.toObject();
@@ -16138,11 +16473,11 @@ var Client = class extends BaseClient {
    */
   async runNodeWithInputs({ nodeType, nodeConfig, inputVariables = {} }, options) {
     const triggerTypes = [
-      TriggerType8.Block,
-      TriggerType8.FixedTime,
-      TriggerType8.Cron,
-      TriggerType8.Event,
-      TriggerType8.Manual
+      TriggerType13.Block,
+      TriggerType13.FixedTime,
+      TriggerType13.Cron,
+      TriggerType13.Event,
+      TriggerType13.Manual
     ];
     if (triggerTypes.includes(nodeType)) {
       return {
@@ -16198,17 +16533,15 @@ var Client = class extends BaseClient {
   }
   /**
    * Simulate a complete task execution including trigger and all workflow nodes
-   * @param {SimulateTaskRequest} params - The parameters for simulating the task
+   * @param {SimulateWorkflowRequest} params - The parameters for simulating the task
    * @param {Record<string, any>} params.trigger - The trigger configuration
    * @param {Array<Record<string, any>>} params.nodes - The workflow nodes
    * @param {Array<Record<string, any>>} params.edges - The workflow edges
-   * @param {string} params.triggerType - The type of the trigger
-   * @param {Record<string, any>} params.triggerConfig - The trigger configuration
    * @param {Record<string, any>} params.inputVariables - Input variables for the simulation
    * @param {RequestOptions} options - Request options
    * @returns {Promise<Execution>} - The response from simulating the task
    */
-  async simulateTask({ trigger, nodes, edges, triggerType, triggerConfig = {}, inputVariables = {} }, options) {
+  async simulateWorkflow({ trigger, nodes, edges, inputVariables = {} }, options) {
     const request = new avs_pb22.SimulateTaskReq();
     const triggerSdk = factory_default.create(trigger);
     request.setTrigger(triggerSdk.toRequest());
@@ -16222,12 +16555,6 @@ var Client = class extends BaseClient {
       return edgeSdk.toRequest();
     });
     request.setEdgesList(edgeMessages);
-    const protobufTriggerType = TriggerTypeGoConverter.fromGoString(triggerType);
-    request.setTriggerType(protobufTriggerType);
-    const triggerConfigMap = request.getTriggerConfigMap();
-    for (const [key, value] of Object.entries(triggerConfig)) {
-      triggerConfigMap.set(key, convertJSValueToProtobuf(value));
-    }
     const inputVarsMap = request.getInputVariablesMap();
     for (const [key, value] of Object.entries(inputVariables)) {
       inputVarsMap.set(key, convertJSValueToProtobuf(value));
@@ -16235,6 +16562,29 @@ var Client = class extends BaseClient {
     const result = await this.sendGrpcRequest("simulateTask", request, options);
     return execution_default.fromResponse(result);
   }
+  /**
+   * Get token metadata by contract address
+   * @param {GetTokenMetadataRequest} params - The parameters for getting token metadata
+   * @param {string} params.address - The contract address to look up
+   * @param {RequestOptions} options - Request options
+   * @returns {Promise<GetTokenMetadataResponse>} - The response containing token metadata
+   */
+  async getTokenMetadata({ address }, options) {
+    const request = new avs_pb22.GetTokenMetadataReq();
+    request.setAddress(address);
+    const result = await this.sendGrpcRequest("getTokenMetadata", request, options);
+    const token = result.getToken();
+    return {
+      token: token ? {
+        address: token.getAddress()?.toLowerCase(),
+        name: token.getName(),
+        symbol: token.getSymbol(),
+        decimals: token.getDecimals()
+      } : null,
+      found: result.getFound(),
+      source: result.getSource()
+    };
+  }
 };
 export {
   block_default as BlockTrigger,