@avaprotocol/sdk-js 2.1.0 → 2.2.0

package/dist/index.js

@@ -66,6 +66,9 @@ var require_avs_pb = __commonJS({
     goog.exportSymbol("proto.aggregator.BranchNode.Output", null, global);
     goog.exportSymbol("proto.aggregator.ContractReadNode", null, global);
     goog.exportSymbol("proto.aggregator.ContractReadNode.Config", null, global);
+    goog.exportSymbol("proto.aggregator.ContractReadNode.MethodCall", null, global);
+    goog.exportSymbol("proto.aggregator.ContractReadNode.MethodResult", null, global);
+    goog.exportSymbol("proto.aggregator.ContractReadNode.MethodResult.StructuredField", null, global);
     goog.exportSymbol("proto.aggregator.ContractReadNode.Output", null, global);
     goog.exportSymbol("proto.aggregator.ContractWriteNode", null, global);
     goog.exportSymbol("proto.aggregator.ContractWriteNode.Config", null, global);
@@ -380,13 +383,34 @@ var require_avs_pb = __commonJS({
     if (goog.DEBUG && !COMPILED) {
       proto.aggregator.ContractReadNode.displayName = "proto.aggregator.ContractReadNode";
     }
-    proto.aggregator.ContractReadNode.Config = function(opt_data) {
+    proto.aggregator.ContractReadNode.MethodCall = function(opt_data) {
       jspb.Message.initialize(this, opt_data, 0, -1, null, null);
     };
+    goog.inherits(proto.aggregator.ContractReadNode.MethodCall, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.ContractReadNode.MethodCall.displayName = "proto.aggregator.ContractReadNode.MethodCall";
+    }
+    proto.aggregator.ContractReadNode.Config = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.ContractReadNode.Config.repeatedFields_, null);
+    };
     goog.inherits(proto.aggregator.ContractReadNode.Config, jspb.Message);
     if (goog.DEBUG && !COMPILED) {
       proto.aggregator.ContractReadNode.Config.displayName = "proto.aggregator.ContractReadNode.Config";
     }
+    proto.aggregator.ContractReadNode.MethodResult = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.ContractReadNode.MethodResult.repeatedFields_, null);
+    };
+    goog.inherits(proto.aggregator.ContractReadNode.MethodResult, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.ContractReadNode.MethodResult.displayName = "proto.aggregator.ContractReadNode.MethodResult";
+    }
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField = function(opt_data) {
+      jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+    };
+    goog.inherits(proto.aggregator.ContractReadNode.MethodResult.StructuredField, jspb.Message);
+    if (goog.DEBUG && !COMPILED) {
+      proto.aggregator.ContractReadNode.MethodResult.StructuredField.displayName = "proto.aggregator.ContractReadNode.MethodResult.StructuredField";
+    }
     proto.aggregator.ContractReadNode.Output = function(opt_data) {
       jspb.Message.initialize(this, opt_data, 0, -1, proto.aggregator.ContractReadNode.Output.repeatedFields_, null);
     };
@@ -3854,6 +3878,95 @@ var require_avs_pb = __commonJS({
         );
       }
     };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.ContractReadNode.MethodCall.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.ContractReadNode.MethodCall.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.ContractReadNode.MethodCall.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          callData: jspb.Message.getFieldWithDefault(msg, 1, ""),
+          methodName: jspb.Message.getFieldWithDefault(msg, 2, "")
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.ContractReadNode.MethodCall.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.ContractReadNode.MethodCall();
+      return proto.aggregator.ContractReadNode.MethodCall.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.ContractReadNode.MethodCall.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.setCallData(value);
+            break;
+          case 2:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setMethodName(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.ContractReadNode.MethodCall.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.ContractReadNode.MethodCall.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.ContractReadNode.MethodCall.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getCallData();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
+      }
+      f = message.getMethodName();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
+      }
+    };
+    proto.aggregator.ContractReadNode.MethodCall.prototype.getCallData = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.ContractReadNode.MethodCall.prototype.setCallData = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    proto.aggregator.ContractReadNode.MethodCall.prototype.getMethodName = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
+      );
+    };
+    proto.aggregator.ContractReadNode.MethodCall.prototype.setMethodName = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
+    };
+    proto.aggregator.ContractReadNode.Config.repeatedFields_ = [3];
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.ContractReadNode.Config.prototype.toObject = function(opt_includeInstance) {
         return proto.aggregator.ContractReadNode.Config.toObject(opt_includeInstance, this);
@@ -3861,8 +3974,12 @@ var require_avs_pb = __commonJS({
       proto.aggregator.ContractReadNode.Config.toObject = function(includeInstance, msg) {
         var f, obj = {
           contractAddress: jspb.Message.getFieldWithDefault(msg, 1, ""),
-          callData: jspb.Message.getFieldWithDefault(msg, 2, ""),
-          contractAbi: jspb.Message.getFieldWithDefault(msg, 3, "")
+          contractAbi: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          methodCallsList: jspb.Message.toObjectList(
+            msg.getMethodCallsList(),
+            proto.aggregator.ContractReadNode.MethodCall.toObject,
+            includeInstance
+          )
         };
         if (includeInstance) {
           obj.$jspbMessageInstance = msg;
@@ -3894,14 +4011,12 @@ var require_avs_pb = __commonJS({
               /** @type {string} */
               reader.readString()
             );
-            msg.setCallData(value);
+            msg.setContractAbi(value);
             break;
           case 3:
-            var value = (
-              /** @type {string} */
-              reader.readString()
-            );
-            msg.setContractAbi(value);
+            var value = new proto.aggregator.ContractReadNode.MethodCall();
+            reader.readMessage(value, proto.aggregator.ContractReadNode.MethodCall.deserializeBinaryFromReader);
+            msg.addMethodCalls(value);
             break;
           default:
             reader.skipField();
@@ -3924,18 +4039,19 @@ var require_avs_pb = __commonJS({
           f
         );
       }
-      f = message.getCallData();
+      f = message.getContractAbi();
       if (f.length > 0) {
         writer.writeString(
           2,
           f
         );
       }
-      f = message.getContractAbi();
+      f = message.getMethodCallsList();
       if (f.length > 0) {
-        writer.writeString(
+        writer.writeRepeatedMessage(
           3,
-          f
+          f,
+          proto.aggregator.ContractReadNode.MethodCall.serializeBinaryToWriter
         );
       }
     };
@@ -3948,24 +4064,288 @@ var require_avs_pb = __commonJS({
     proto.aggregator.ContractReadNode.Config.prototype.setContractAddress = function(value) {
       return jspb.Message.setProto3StringField(this, 1, value);
     };
-    proto.aggregator.ContractReadNode.Config.prototype.getCallData = function() {
+    proto.aggregator.ContractReadNode.Config.prototype.getContractAbi = function() {
       return (
         /** @type {string} */
         jspb.Message.getFieldWithDefault(this, 2, "")
       );
     };
-    proto.aggregator.ContractReadNode.Config.prototype.setCallData = function(value) {
+    proto.aggregator.ContractReadNode.Config.prototype.setContractAbi = function(value) {
       return jspb.Message.setProto3StringField(this, 2, value);
     };
-    proto.aggregator.ContractReadNode.Config.prototype.getContractAbi = function() {
+    proto.aggregator.ContractReadNode.Config.prototype.getMethodCallsList = function() {
+      return (
+        /** @type{!Array<!proto.aggregator.ContractReadNode.MethodCall>} */
+        jspb.Message.getRepeatedWrapperField(this, proto.aggregator.ContractReadNode.MethodCall, 3)
+      );
+    };
+    proto.aggregator.ContractReadNode.Config.prototype.setMethodCallsList = function(value) {
+      return jspb.Message.setRepeatedWrapperField(this, 3, value);
+    };
+    proto.aggregator.ContractReadNode.Config.prototype.addMethodCalls = function(opt_value, opt_index) {
+      return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.aggregator.ContractReadNode.MethodCall, opt_index);
+    };
+    proto.aggregator.ContractReadNode.Config.prototype.clearMethodCallsList = function() {
+      return this.setMethodCallsList([]);
+    };
+    proto.aggregator.ContractReadNode.MethodResult.repeatedFields_ = [1];
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.ContractReadNode.MethodResult.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.ContractReadNode.MethodResult.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.ContractReadNode.MethodResult.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          dataList: jspb.Message.toObjectList(
+            msg.getDataList(),
+            proto.aggregator.ContractReadNode.MethodResult.StructuredField.toObject,
+            includeInstance
+          ),
+          methodName: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          success: jspb.Message.getBooleanFieldWithDefault(msg, 3, false),
+          error: jspb.Message.getFieldWithDefault(msg, 4, "")
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.ContractReadNode.MethodResult.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.ContractReadNode.MethodResult();
+      return proto.aggregator.ContractReadNode.MethodResult.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.ContractReadNode.MethodResult.deserializeBinaryFromReader = function(msg, reader) {
+      while (reader.nextField()) {
+        if (reader.isEndGroup()) {
+          break;
+        }
+        var field = reader.getFieldNumber();
+        switch (field) {
+          case 1:
+            var value = new proto.aggregator.ContractReadNode.MethodResult.StructuredField();
+            reader.readMessage(value, proto.aggregator.ContractReadNode.MethodResult.StructuredField.deserializeBinaryFromReader);
+            msg.addData(value);
+            break;
+          case 2:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setMethodName(value);
+            break;
+          case 3:
+            var value = (
+              /** @type {boolean} */
+              reader.readBool()
+            );
+            msg.setSuccess(value);
+            break;
+          case 4:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setError(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.ContractReadNode.MethodResult.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.ContractReadNode.MethodResult.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getDataList();
+      if (f.length > 0) {
+        writer.writeRepeatedMessage(
+          1,
+          f,
+          proto.aggregator.ContractReadNode.MethodResult.StructuredField.serializeBinaryToWriter
+        );
+      }
+      f = message.getMethodName();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
+      }
+      f = message.getSuccess();
+      if (f) {
+        writer.writeBool(
+          3,
+          f
+        );
+      }
+      f = message.getError();
+      if (f.length > 0) {
+        writer.writeString(
+          4,
+          f
+        );
+      }
+    };
+    if (jspb.Message.GENERATE_TO_OBJECT) {
+      proto.aggregator.ContractReadNode.MethodResult.StructuredField.prototype.toObject = function(opt_includeInstance) {
+        return proto.aggregator.ContractReadNode.MethodResult.StructuredField.toObject(opt_includeInstance, this);
+      };
+      proto.aggregator.ContractReadNode.MethodResult.StructuredField.toObject = function(includeInstance, msg) {
+        var f, obj = {
+          name: jspb.Message.getFieldWithDefault(msg, 1, ""),
+          type: jspb.Message.getFieldWithDefault(msg, 2, ""),
+          value: jspb.Message.getFieldWithDefault(msg, 3, "")
+        };
+        if (includeInstance) {
+          obj.$jspbMessageInstance = msg;
+        }
+        return obj;
+      };
+    }
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField.deserializeBinary = function(bytes) {
+      var reader = new jspb.BinaryReader(bytes);
+      var msg = new proto.aggregator.ContractReadNode.MethodResult.StructuredField();
+      return proto.aggregator.ContractReadNode.MethodResult.StructuredField.deserializeBinaryFromReader(msg, reader);
+    };
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField.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.setName(value);
+            break;
+          case 2:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setType(value);
+            break;
+          case 3:
+            var value = (
+              /** @type {string} */
+              reader.readString()
+            );
+            msg.setValue(value);
+            break;
+          default:
+            reader.skipField();
+            break;
+        }
+      }
+      return msg;
+    };
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField.prototype.serializeBinary = function() {
+      var writer = new jspb.BinaryWriter();
+      proto.aggregator.ContractReadNode.MethodResult.StructuredField.serializeBinaryToWriter(this, writer);
+      return writer.getResultBuffer();
+    };
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField.serializeBinaryToWriter = function(message, writer) {
+      var f = void 0;
+      f = message.getName();
+      if (f.length > 0) {
+        writer.writeString(
+          1,
+          f
+        );
+      }
+      f = message.getType();
+      if (f.length > 0) {
+        writer.writeString(
+          2,
+          f
+        );
+      }
+      f = message.getValue();
+      if (f.length > 0) {
+        writer.writeString(
+          3,
+          f
+        );
+      }
+    };
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField.prototype.getName = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 1, "")
+      );
+    };
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField.prototype.setName = function(value) {
+      return jspb.Message.setProto3StringField(this, 1, value);
+    };
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField.prototype.getType = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
+      );
+    };
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField.prototype.setType = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
+    };
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField.prototype.getValue = function() {
       return (
         /** @type {string} */
         jspb.Message.getFieldWithDefault(this, 3, "")
       );
     };
-    proto.aggregator.ContractReadNode.Config.prototype.setContractAbi = function(value) {
+    proto.aggregator.ContractReadNode.MethodResult.StructuredField.prototype.setValue = function(value) {
       return jspb.Message.setProto3StringField(this, 3, value);
     };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.getDataList = function() {
+      return (
+        /** @type{!Array<!proto.aggregator.ContractReadNode.MethodResult.StructuredField>} */
+        jspb.Message.getRepeatedWrapperField(this, proto.aggregator.ContractReadNode.MethodResult.StructuredField, 1)
+      );
+    };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.setDataList = function(value) {
+      return jspb.Message.setRepeatedWrapperField(this, 1, value);
+    };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.addData = function(opt_value, opt_index) {
+      return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.aggregator.ContractReadNode.MethodResult.StructuredField, opt_index);
+    };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.clearDataList = function() {
+      return this.setDataList([]);
+    };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.getMethodName = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 2, "")
+      );
+    };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.setMethodName = function(value) {
+      return jspb.Message.setProto3StringField(this, 2, value);
+    };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.getSuccess = function() {
+      return (
+        /** @type {boolean} */
+        jspb.Message.getBooleanFieldWithDefault(this, 3, false)
+      );
+    };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.setSuccess = function(value) {
+      return jspb.Message.setProto3BooleanField(this, 3, value);
+    };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.getError = function() {
+      return (
+        /** @type {string} */
+        jspb.Message.getFieldWithDefault(this, 4, "")
+      );
+    };
+    proto.aggregator.ContractReadNode.MethodResult.prototype.setError = function(value) {
+      return jspb.Message.setProto3StringField(this, 4, value);
+    };
     proto.aggregator.ContractReadNode.Output.repeatedFields_ = [1];
     if (jspb.Message.GENERATE_TO_OBJECT) {
       proto.aggregator.ContractReadNode.Output.prototype.toObject = function(opt_includeInstance) {
@@ -3973,9 +4353,9 @@ var require_avs_pb = __commonJS({
       };
       proto.aggregator.ContractReadNode.Output.toObject = function(includeInstance, msg) {
         var f, obj = {
-          dataList: jspb.Message.toObjectList(
-            msg.getDataList(),
-            google_protobuf_struct_pb.Value.toObject,
+          resultsList: jspb.Message.toObjectList(
+            msg.getResultsList(),
+            proto.aggregator.ContractReadNode.MethodResult.toObject,
             includeInstance
           )
         };
@@ -3998,9 +4378,9 @@ var require_avs_pb = __commonJS({
         var field = reader.getFieldNumber();
         switch (field) {
           case 1:
-            var value = new google_protobuf_struct_pb.Value();
-            reader.readMessage(value, google_protobuf_struct_pb.Value.deserializeBinaryFromReader);
-            msg.addData(value);
+            var value = new proto.aggregator.ContractReadNode.MethodResult();
+            reader.readMessage(value, proto.aggregator.ContractReadNode.MethodResult.deserializeBinaryFromReader);
+            msg.addResults(value);
             break;
           default:
             reader.skipField();
@@ -4016,29 +4396,29 @@ var require_avs_pb = __commonJS({
     };
     proto.aggregator.ContractReadNode.Output.serializeBinaryToWriter = function(message, writer) {
       var f = void 0;
-      f = message.getDataList();
+      f = message.getResultsList();
       if (f.length > 0) {
         writer.writeRepeatedMessage(
           1,
           f,
-          google_protobuf_struct_pb.Value.serializeBinaryToWriter
+          proto.aggregator.ContractReadNode.MethodResult.serializeBinaryToWriter
         );
       }
     };
-    proto.aggregator.ContractReadNode.Output.prototype.getDataList = function() {
+    proto.aggregator.ContractReadNode.Output.prototype.getResultsList = function() {
       return (
-        /** @type{!Array<!proto.google.protobuf.Value>} */
-        jspb.Message.getRepeatedWrapperField(this, google_protobuf_struct_pb.Value, 1)
+        /** @type{!Array<!proto.aggregator.ContractReadNode.MethodResult>} */
+        jspb.Message.getRepeatedWrapperField(this, proto.aggregator.ContractReadNode.MethodResult, 1)
       );
     };
-    proto.aggregator.ContractReadNode.Output.prototype.setDataList = function(value) {
+    proto.aggregator.ContractReadNode.Output.prototype.setResultsList = function(value) {
       return jspb.Message.setRepeatedWrapperField(this, 1, value);
     };
-    proto.aggregator.ContractReadNode.Output.prototype.addData = function(opt_value, opt_index) {
-      return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.google.protobuf.Value, opt_index);
+    proto.aggregator.ContractReadNode.Output.prototype.addResults = function(opt_value, opt_index) {
+      return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.aggregator.ContractReadNode.MethodResult, opt_index);
     };
-    proto.aggregator.ContractReadNode.Output.prototype.clearDataList = function() {
-      return this.setDataList([]);
+    proto.aggregator.ContractReadNode.Output.prototype.clearResultsList = function() {
+      return this.setResultsList([]);
     };
     proto.aggregator.ContractReadNode.prototype.getConfig = function() {
       return (
@@ -14514,6 +14894,7 @@ __export(index_exports, {
   RestAPINode: () => restApi_default,
   Secret: () => secret_default,
   Step: () => step_default,
+  TimeoutPresets: () => import_types21.TimeoutPresets,
   Trigger: () => interface_default,
   TriggerFactory: () => factory_default,
   Workflow: () => workflow_default
@@ -15375,18 +15756,35 @@ var ContractReadNode2 = class _ContractReadNode extends interface_default2 {
     const nodeData = new avs_pb13.ContractReadNode();
     const config = new avs_pb13.ContractReadNode.Config();
     config.setContractAddress(this.data.contractAddress);
-    config.setCallData(this.data.callData);
     config.setContractAbi(this.data.contractAbi);
+    const methodCalls = this.data.methodCallsList || [];
+    methodCalls.forEach((methodCall) => {
+      const methodCallMsg = new avs_pb13.ContractReadNode.MethodCall();
+      methodCallMsg.setCallData(methodCall.callData);
+      if (methodCall.methodName) {
+        methodCallMsg.setMethodName(methodCall.methodName);
+      }
+      config.addMethodCalls(methodCallMsg);
+    });
     nodeData.setConfig(config);
     request.setContractRead(nodeData);
     return request;
   }
   static fromOutputData(outputData) {
     const contractReadOutput = outputData.getContractRead();
-    if (contractReadOutput && contractReadOutput.getDataList()) {
-      const dataList = contractReadOutput.getDataList();
+    if (contractReadOutput && contractReadOutput.getResultsList()) {
+      const resultsList = contractReadOutput.getResultsList();
       return {
-        dataList: dataList.map((value) => convertProtobufValueToJs(value))
+        results: resultsList.map((result) => ({
+          methodName: result.getMethodName(),
+          success: result.getSuccess(),
+          error: result.getError(),
+          data: result.getDataList().map((field) => ({
+            name: field.getName(),
+            type: field.getType(),
+            value: field.getValue()
+          }))
+        }))
       };
     }
     return null;
@@ -15573,8 +15971,16 @@ var LoopNode2 = class _LoopNode extends interface_default2 {
       if (data.contractRead.config) {
         const config2 = new avs_pb17.ContractReadNode.Config();
         config2.setContractAddress(data.contractRead.config.contractAddress);
-        config2.setCallData(data.contractRead.config.callData);
         config2.setContractAbi(data.contractRead.config.contractAbi);
+        const methodCalls = data.contractRead.config.methodCallsList || [];
+        methodCalls.forEach((methodCall) => {
+          const methodCallMsg = new avs_pb17.ContractReadNode.MethodCall();
+          methodCallMsg.setCallData(methodCall.callData);
+          if (methodCall.methodName) {
+            methodCallMsg.setMethodName(methodCall.methodName);
+          }
+          config2.addMethodCalls(methodCallMsg);
+        });
         contractRead.setConfig(config2);
       }
       loopNode.setContractRead(contractRead);
@@ -15734,7 +16140,7 @@ var factory_default2 = NodeFactory;
 
 // src/models/workflow.ts
 var import_types19 = require("@avaprotocol/types");
-function convertStatusToString(status) {
+function convertStatusToString(status2) {
   const conversionMap = {
     [avs_pb19.TaskStatus.ACTIVE]: import_types19.WorkflowStatus.Active,
     [avs_pb19.TaskStatus.COMPLETED]: import_types19.WorkflowStatus.Completed,
@@ -15742,7 +16148,7 @@ function convertStatusToString(status) {
     [avs_pb19.TaskStatus.CANCELED]: import_types19.WorkflowStatus.Canceled,
     [avs_pb19.TaskStatus.EXECUTING]: import_types19.WorkflowStatus.Executing
   };
-  return conversionMap[status];
+  return conversionMap[status2];
 }
 var Workflow = class _Workflow {
   /**
@@ -15946,9 +16352,37 @@ var Step = class _Step {
       case avs_pb20.Execution.Step.OutputDataCase.CONTRACT_READ:
         nodeOutputMessage = step.getContractRead();
         if (nodeOutputMessage) {
-          return nodeOutputMessage.getDataList().map((val) => convertProtobufValueToJs(val));
+          const results = nodeOutputMessage.getResultsList();
+          if (results && results.length > 0) {
+            if (results.length === 1) {
+              const result = results[0];
+              const structuredData = {};
+              result.getDataList().forEach((field) => {
+                structuredData[field.getName()] = field.getValue();
+              });
+              return {
+                methodName: result.getMethodName(),
+                success: result.getSuccess(),
+                error: result.getError(),
+                data: structuredData
+              };
+            } else {
+              return results.map((result) => {
+                const structuredData = {};
+                result.getDataList().forEach((field) => {
+                  structuredData[field.getName()] = field.getValue();
+                });
+                return {
+                  methodName: result.getMethodName(),
+                  success: result.getSuccess(),
+                  error: result.getError(),
+                  data: structuredData
+                };
+              });
+            }
+          }
         }
-        return [];
+        return void 0;
       case avs_pb20.Execution.Step.OutputDataCase.CONTRACT_WRITE:
         return step.getContractWrite()?.toObject();
       case avs_pb20.Execution.Step.OutputDataCase.CUSTOM_CODE:
@@ -16059,6 +16493,7 @@ var secret_default = Secret;
 
 // src/index.ts
 var import_types20 = require("@avaprotocol/types");
+var import_types21 = require("@avaprotocol/types");
 var BaseClient = class {
   constructor(opts) {
     this.endpoint = opts.endpoint;
@@ -16067,8 +16502,67 @@ var BaseClient = class {
       import_grpc_js.credentials.createInsecure()
     );
     this.factoryAddress = opts.factoryAddress;
+    this.timeoutConfig = {
+      timeout: 3e4,
+      retries: 0,
+      retryDelay: 0,
+      ...opts.timeout
+    };
     this.metadata = new import_grpc_js.Metadata();
   }
+  /**
+   * Set default timeout configuration for all requests
+   * @param config - The timeout configuration
+   */
+  setTimeoutConfig(config) {
+    this.timeoutConfig = { ...this.timeoutConfig, ...config };
+  }
+  /**
+   * Get the current timeout configuration
+   * @returns {TimeoutConfig} - The current timeout configuration
+   */
+  getTimeoutConfig() {
+    return { ...this.timeoutConfig };
+  }
+  /**
+   * Send a fast gRPC request using FAST preset (5s timeout, 2 retries)
+   * @param method - The method name to call
+   * @param request - The request object
+   * @param options - Request options
+   * @returns {Promise<TResponse>} - The response from the server
+   */
+  sendFastRequest(method, request, options) {
+    return this.sendGrpcRequest(method, request, {
+      ...options,
+      timeout: import_types20.TimeoutPresets.FAST
+    });
+  }
+  /**
+   * Send a slow gRPC request using SLOW preset (2min timeout, 2 retries)
+   * @param method - The method name to call
+   * @param request - The request object
+   * @param options - Request options
+   * @returns {Promise<TResponse>} - The response from the server
+   */
+  sendSlowRequest(method, request, options) {
+    return this.sendGrpcRequest(method, request, {
+      ...options,
+      timeout: import_types20.TimeoutPresets.SLOW
+    });
+  }
+  /**
+   * Send a no-retry gRPC request using NO_RETRY preset (30s timeout, no retries)
+   * @param method - The method name to call
+   * @param request - The request object
+   * @param options - Request options
+   * @returns {Promise<TResponse>} - The response from the server
+   */
+  sendNoRetryRequest(method, request, options) {
+    return this.sendGrpcRequest(method, request, {
+      ...options,
+      timeout: import_types20.TimeoutPresets.NO_RETRY
+    });
+  }
   /**
    * Check if the auth key is valid by decoding the JWT token and checking the expiration
    * @param key - The auth key
@@ -16161,30 +16655,126 @@ var BaseClient = class {
     return this.factoryAddress;
   }
   /**
-   * Send a gRPC request with authentication and error handling
+   * Send a gRPC request with authentication, timeout support, and error handling
    * @param method - The method name to call
    * @param request - The request object
-   * @param options - Request options
+   * @param options - Request options including timeout configuration
    * @returns {Promise<TResponse>} - The response from the server
    */
   sendGrpcRequest(method, request, options) {
     return new Promise((resolve, reject) => {
-      const metadata = new import_grpc_js.Metadata();
-      const authKey = options?.authKey || this.authKey;
-      if (authKey) {
-        metadata.set(import_types20.AUTH_KEY_HEADER, authKey);
-      }
-      this.rpcClient[method](
-        request,
-        metadata,
-        (error, response) => {
-          if (error) {
-            reject(error);
-          } else {
-            resolve(response);
+      const debugMode = process.env.GRPC_DEBUG === "true";
+      if (debugMode) {
+        console.log(`\u{1F50D} [GRPC-DEBUG] Starting ${method} request:`, {
+          method,
+          hasAuthKey: !!(options?.authKey || this.authKey),
+          endpoint: this.endpoint
+        });
+        try {
+          const serializedRequest = request.serializeBinary?.();
+          if (serializedRequest) {
+            console.log(`\u{1F50D} [GRPC-DEBUG] Request serialized, size: ${serializedRequest.length} bytes`);
           }
+        } catch (error) {
+          console.error(`\u274C [GRPC-DEBUG] Failed to serialize request for logging:`, error);
         }
-      );
+      }
+      const timeoutConfig = {
+        ...this.timeoutConfig,
+        ...options?.timeout
+      };
+      const {
+        timeout = timeoutConfig.timeout || 3e4,
+        retries = timeoutConfig.retries || 3,
+        retryDelay = timeoutConfig.retryDelay || 1e3
+      } = timeoutConfig;
+      if (debugMode) {
+        console.log(`\u{1F50D} [GRPC-DEBUG] Timeout configuration:`, {
+          timeout,
+          retries,
+          retryDelay
+        });
+      }
+      let attempt = 0;
+      const executeRequest = () => {
+        attempt++;
+        let timeoutId;
+        const timeoutPromise = new Promise((_4, timeoutReject) => {
+          timeoutId = setTimeout(() => {
+            const error = new Error(`gRPC request timeout after ${timeout}ms for method ${method}`);
+            error.isTimeout = true;
+            error.attemptsMade = attempt;
+            error.methodName = method;
+            timeoutReject(error);
+          }, timeout);
+        });
+        const grpcPromise = new Promise((grpcResolve, grpcReject) => {
+          const metadata = new import_grpc_js.Metadata();
+          const authKey = options?.authKey || this.authKey;
+          if (authKey) {
+            metadata.set(import_types20.AUTH_KEY_HEADER, authKey);
+          }
+          if (debugMode) {
+            console.log(`\u{1F50D} [GRPC-DEBUG] Making gRPC call for ${method}, attempt ${attempt}`);
+          }
+          const call = this.rpcClient[method](
+            request,
+            metadata,
+            (error, response) => {
+              if (error) {
+                if (debugMode) {
+                  console.error(`\u274C [GRPC-DEBUG] gRPC call failed for ${method}:`, {
+                    code: error.code,
+                    message: error.message,
+                    details: error.details,
+                    metadata: error.metadata?.getMap ? error.metadata.getMap() : error.metadata
+                  });
+                }
+                grpcReject(error);
+              } else {
+                if (debugMode) {
+                  try {
+                    const responseObj = response?.toObject ? response.toObject() : response;
+                    console.log(`\u2705 [GRPC-DEBUG] gRPC call succeeded for ${method}:`, {
+                      responseType: typeof response,
+                      hasToObject: !!response?.toObject,
+                      sampleResponse: JSON.stringify(responseObj).substring(0, 500) + (JSON.stringify(responseObj).length > 500 ? "..." : "")
+                    });
+                  } catch (parseError) {
+                    console.log(`\u2705 [GRPC-DEBUG] gRPC call succeeded for ${method}, but failed to parse response for logging:`, parseError);
+                  }
+                }
+                grpcResolve(response);
+              }
+            }
+          );
+          timeoutPromise.catch(() => {
+            if (call && call.cancel) {
+              call.cancel();
+            }
+          });
+        });
+        Promise.race([grpcPromise, timeoutPromise]).then((result) => {
+          clearTimeout(timeoutId);
+          resolve(result);
+        }).catch((error) => {
+          clearTimeout(timeoutId);
+          const isTimeoutError = error.isTimeout || error.message?.includes("timeout");
+          const isRetryableError = isTimeoutError || error.code === import_grpc_js.status.UNAVAILABLE || error.code === import_grpc_js.status.DEADLINE_EXCEEDED || error.code === import_grpc_js.status.RESOURCE_EXHAUSTED;
+          if (isRetryableError && attempt < retries) {
+            console.warn(`gRPC ${method} attempt ${attempt} failed, retrying in ${retryDelay}ms:`, error.message);
+            setTimeout(executeRequest, retryDelay);
+          } else {
+            if (isTimeoutError && !error.isTimeout) {
+              error.isTimeout = true;
+              error.attemptsMade = attempt;
+              error.methodName = method;
+            }
+            reject(error);
+          }
+        });
+      };
+      executeRequest();
     });
   }
 };
@@ -16691,6 +17281,14 @@ var Client = class extends BaseClient {
    * @returns {Promise<RunNodeWithInputsResponse>} - The response from running the node
    */
   async runNodeWithInputs({ nodeType, nodeConfig, inputVariables = {} }, options) {
+    const debugMode = process.env.GRPC_DEBUG === "true";
+    if (debugMode) {
+      console.log("\u{1F50D} [GRPC-DEBUG] runNodeWithInputs called with:", {
+        nodeType,
+        nodeConfig: JSON.stringify(nodeConfig, null, 2),
+        inputVariables: JSON.stringify(inputVariables, null, 2)
+      });
+    }
     const triggerTypes = [
       import_types20.TriggerType.Block,
       import_types20.TriggerType.FixedTime,
@@ -16708,23 +17306,94 @@ var Client = class extends BaseClient {
     const request = new avs_pb22.RunNodeWithInputsReq();
     const protobufNodeType = import_types20.NodeTypeGoConverter.fromGoString(nodeType);
     request.setNodeType(protobufNodeType);
+    if (debugMode) {
+      console.log("\u{1F50D} [GRPC-DEBUG] Converted nodeType:", {
+        original: nodeType,
+        protobuf: protobufNodeType
+      });
+    }
     const nodeConfigMap = request.getNodeConfigMap();
     for (const [key, value] of Object.entries(nodeConfig)) {
-      nodeConfigMap.set(key, convertJSValueToProtobuf(value));
+      try {
+        const protobufValue = convertJSValueToProtobuf(value);
+        nodeConfigMap.set(key, protobufValue);
+        if (debugMode) {
+          console.log(`\u{1F50D} [GRPC-DEBUG] Converted nodeConfig[${key}]:`, {
+            original: value,
+            protobuf: protobufValue?.toObject ? protobufValue.toObject() : protobufValue
+          });
+        }
+      } catch (error) {
+        console.error(`\u274C [GRPC-DEBUG] Failed to convert nodeConfig[${key}]:`, error);
+        throw error;
+      }
     }
     if (inputVariables && Object.keys(inputVariables).length > 0) {
       const inputVarsMap = request.getInputVariablesMap();
       for (const [key, value] of Object.entries(inputVariables)) {
-        inputVarsMap.set(key, convertJSValueToProtobuf(value));
+        try {
+          const protobufValue = convertJSValueToProtobuf(value);
+          inputVarsMap.set(key, protobufValue);
+          if (debugMode) {
+            console.log(`\u{1F50D} [GRPC-DEBUG] Converted inputVariable[${key}]:`, {
+              original: value,
+              protobuf: protobufValue?.toObject ? protobufValue.toObject() : protobufValue
+            });
+          }
+        } catch (error) {
+          console.error(`\u274C [GRPC-DEBUG] Failed to convert inputVariable[${key}]:`, error);
+          throw error;
+        }
       }
     }
-    const result = await this.sendGrpcRequest("runNodeWithInputs", request, options);
-    return {
-      success: result.getSuccess(),
-      data: factory_default2.fromOutputData(result),
-      error: result.getError(),
-      nodeId: result.getNodeId()
-    };
+    if (debugMode) {
+      try {
+        const serializedRequest = request.serializeBinary();
+        console.log("\u{1F50D} [GRPC-DEBUG] Request serialized successfully, size:", serializedRequest.length, "bytes");
+      } catch (error) {
+        console.error("\u274C [GRPC-DEBUG] Failed to serialize request:", error);
+        throw error;
+      }
+    }
+    try {
+      const result = await this.sendGrpcRequest("runNodeWithInputs", request, options);
+      if (debugMode) {
+        console.log("\u{1F50D} [GRPC-DEBUG] Response received successfully:", {
+          success: result.getSuccess(),
+          error: result.getError(),
+          nodeId: result.getNodeId(),
+          outputDataCase: result.getOutputDataCase()
+        });
+      }
+      let responseData;
+      try {
+        responseData = factory_default2.fromOutputData(result);
+        if (debugMode) {
+          console.log("\u{1F50D} [GRPC-DEBUG] Output data parsed successfully:", responseData);
+        }
+      } catch (error) {
+        console.error("\u274C [GRPC-DEBUG] Failed to parse output data:", error);
+        if (debugMode) {
+          console.log("\u{1F50D} [GRPC-DEBUG] Raw response object:", result.toObject());
+        }
+        throw error;
+      }
+      return {
+        success: result.getSuccess(),
+        data: responseData,
+        error: result.getError(),
+        nodeId: result.getNodeId()
+      };
+    } catch (error) {
+      console.error("\u274C [GRPC-DEBUG] runNodeWithInputs failed:", {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        nodeType,
+        nodeConfig,
+        inputVariables
+      });
+      throw error;
+    }
   }
   /**
    * Run a trigger for testing purposes
@@ -16830,6 +17499,7 @@ var Client = class extends BaseClient {
   RestAPINode,
   Secret,
   Step,
+  TimeoutPresets,
   Trigger,
   TriggerFactory,
   Workflow