@glowlabs-org/utils 0.1.5 → 0.2.0

package/dist/esm/index.js

@@ -5,7 +5,7 @@ import require$$3 from 'http';
 import require$$4 from 'https';
 import require$$0$1 from 'url';
 import require$$6 from 'fs';
-import crypto from 'crypto';
+import require$$8 from 'crypto';
 import require$$4$1 from 'assert';
 import zlib from 'zlib';
 import { EventEmitter } from 'events';
@@ -16,7 +16,7 @@ import Decimal from 'decimal.js';
 
 const GENESIS_TIMESTAMP = 1700352000;
 
-function bind$1(fn, thisArg) {
+function bind$2(fn, thisArg) {
   return function wrap() {
     return fn.apply(thisArg, arguments);
   };
@@ -156,6 +156,27 @@ const isPlainObject = (val) => {
   return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag$1 in val) && !(iterator in val);
 };
 
+/**
+ * Determine if a value is an empty object (safely handles Buffers)
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is an empty object, otherwise false
+ */
+const isEmptyObject = (val) => {
+  // Early return for non-objects or Buffers to prevent RangeError
+  if (!isObject(val) || isBuffer$1(val)) {
+    return false;
+  }
+  
+  try {
+    return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
+  } catch (e) {
+    // Fallback for any other objects that might cause RangeError with Object.keys()
+    return false;
+  }
+};
+
 /**
  * Determine if a value is a Date
  *
@@ -278,6 +299,11 @@ function forEach(obj, fn, {allOwnKeys = false} = {}) {
       fn.call(null, obj[i], i, obj);
     }
   } else {
+    // Buffer check
+    if (isBuffer$1(obj)) {
+      return;
+    }
+
     // Iterate over object keys
     const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
     const len = keys.length;
@@ -291,6 +317,10 @@ function forEach(obj, fn, {allOwnKeys = false} = {}) {
 }
 
 function findKey(obj, key) {
+  if (isBuffer$1(obj)){
+    return null;
+  }
+
   key = key.toLowerCase();
   const keys = Object.keys(obj);
   let i = keys.length;
@@ -365,7 +395,7 @@ function merge(/* obj1, obj2, obj3, ... */) {
 const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
   forEach(b, (val, key) => {
     if (thisArg && isFunction$1(val)) {
-      a[key] = bind$1(val, thisArg);
+      a[key] = bind$2(val, thisArg);
     } else {
       a[key] = val;
     }
@@ -644,6 +674,11 @@ const toJSONObject = (obj) => {
         return;
       }
 
+      //Buffer check
+      if (isBuffer$1(source)) {
+        return source;
+      }
+
       if(!('toJSON' in source)) {
         stack[i] = source;
         const target = isArray(source) ? [] : {};
@@ -715,6 +750,7 @@ var utils$1 = {
   isBoolean,
   isObject,
   isPlainObject,
+  isEmptyObject,
   isReadableStream,
   isRequest,
   isResponse,
@@ -12515,7 +12551,7 @@ var abs$1 = Math.abs;
 var floor$1 = Math.floor;
 
 /** @type {import('./max')} */
-var max$1 = Math.max;
+var max$2 = Math.max;
 
 /** @type {import('./min')} */
 var min$1 = Math.min;
@@ -12672,110 +12708,92 @@ function requireObject_getPrototypeOf () {
 	return Object_getPrototypeOf;
 }
 
-var implementation;
-var hasRequiredImplementation;
-
-function requireImplementation () {
-	if (hasRequiredImplementation) return implementation;
-	hasRequiredImplementation = 1;
-
-	/* eslint no-invalid-this: 1 */
-
-	var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
-	var toStr = Object.prototype.toString;
-	var max = Math.max;
-	var funcType = '[object Function]';
-
-	var concatty = function concatty(a, b) {
-	    var arr = [];
+/* eslint no-invalid-this: 1 */
 
-	    for (var i = 0; i < a.length; i += 1) {
-	        arr[i] = a[i];
-	    }
-	    for (var j = 0; j < b.length; j += 1) {
-	        arr[j + a.length] = b[j];
-	    }
+var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+var toStr = Object.prototype.toString;
+var max$1 = Math.max;
+var funcType = '[object Function]';
 
-	    return arr;
-	};
+var concatty = function concatty(a, b) {
+    var arr = [];
 
-	var slicy = function slicy(arrLike, offset) {
-	    var arr = [];
-	    for (var i = offset, j = 0; i < arrLike.length; i += 1, j += 1) {
-	        arr[j] = arrLike[i];
-	    }
-	    return arr;
-	};
+    for (var i = 0; i < a.length; i += 1) {
+        arr[i] = a[i];
+    }
+    for (var j = 0; j < b.length; j += 1) {
+        arr[j + a.length] = b[j];
+    }
 
-	var joiny = function (arr, joiner) {
-	    var str = '';
-	    for (var i = 0; i < arr.length; i += 1) {
-	        str += arr[i];
-	        if (i + 1 < arr.length) {
-	            str += joiner;
-	        }
-	    }
-	    return str;
-	};
+    return arr;
+};
 
-	implementation = function bind(that) {
-	    var target = this;
-	    if (typeof target !== 'function' || toStr.apply(target) !== funcType) {
-	        throw new TypeError(ERROR_MESSAGE + target);
-	    }
-	    var args = slicy(arguments, 1);
-
-	    var bound;
-	    var binder = function () {
-	        if (this instanceof bound) {
-	            var result = target.apply(
-	                this,
-	                concatty(args, arguments)
-	            );
-	            if (Object(result) === result) {
-	                return result;
-	            }
-	            return this;
-	        }
-	        return target.apply(
-	            that,
-	            concatty(args, arguments)
-	        );
+var slicy = function slicy(arrLike, offset) {
+    var arr = [];
+    for (var i = offset, j = 0; i < arrLike.length; i += 1, j += 1) {
+        arr[j] = arrLike[i];
+    }
+    return arr;
+};
 
-	    };
+var joiny = function (arr, joiner) {
+    var str = '';
+    for (var i = 0; i < arr.length; i += 1) {
+        str += arr[i];
+        if (i + 1 < arr.length) {
+            str += joiner;
+        }
+    }
+    return str;
+};
 
-	    var boundLength = max(0, target.length - args.length);
-	    var boundArgs = [];
-	    for (var i = 0; i < boundLength; i++) {
-	        boundArgs[i] = '$' + i;
-	    }
+var implementation$1 = function bind(that) {
+    var target = this;
+    if (typeof target !== 'function' || toStr.apply(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+    }
+    var args = slicy(arguments, 1);
+
+    var bound;
+    var binder = function () {
+        if (this instanceof bound) {
+            var result = target.apply(
+                this,
+                concatty(args, arguments)
+            );
+            if (Object(result) === result) {
+                return result;
+            }
+            return this;
+        }
+        return target.apply(
+            that,
+            concatty(args, arguments)
+        );
 
-	    bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);
+    };
 
-	    if (target.prototype) {
-	        var Empty = function Empty() {};
-	        Empty.prototype = target.prototype;
-	        bound.prototype = new Empty();
-	        Empty.prototype = null;
-	    }
+    var boundLength = max$1(0, target.length - args.length);
+    var boundArgs = [];
+    for (var i = 0; i < boundLength; i++) {
+        boundArgs[i] = '$' + i;
+    }
 
-	    return bound;
-	};
-	return implementation;
-}
+    bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);
 
-var functionBind;
-var hasRequiredFunctionBind;
+    if (target.prototype) {
+        var Empty = function Empty() {};
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+    }
 
-function requireFunctionBind () {
-	if (hasRequiredFunctionBind) return functionBind;
-	hasRequiredFunctionBind = 1;
+    return bound;
+};
 
-	var implementation = requireImplementation();
+var implementation = implementation$1;
 
-	functionBind = Function.prototype.bind || implementation;
-	return functionBind;
-}
+var functionBind = Function.prototype.bind || implementation;
 
 var functionCall;
 var hasRequiredFunctionCall;
@@ -12820,7 +12838,7 @@ function requireActualApply () {
 	if (hasRequiredActualApply) return actualApply;
 	hasRequiredActualApply = 1;
 
-	var bind = requireFunctionBind();
+	var bind = functionBind;
 
 	var $apply = requireFunctionApply();
 	var $call = requireFunctionCall();
@@ -12838,7 +12856,7 @@ function requireCallBindApplyHelpers () {
 	if (hasRequiredCallBindApplyHelpers) return callBindApplyHelpers;
 	hasRequiredCallBindApplyHelpers = 1;
 
-	var bind = requireFunctionBind();
+	var bind = functionBind;
 	var $TypeError = requireType();
 
 	var $call = requireFunctionCall();
@@ -12927,21 +12945,12 @@ function requireGetProto () {
 	return getProto$1;
 }
 
-var hasown;
-var hasRequiredHasown;
-
-function requireHasown () {
-	if (hasRequiredHasown) return hasown;
-	hasRequiredHasown = 1;
+var call = Function.prototype.call;
+var $hasOwn = Object.prototype.hasOwnProperty;
+var bind$1 = functionBind;
 
-	var call = Function.prototype.call;
-	var $hasOwn = Object.prototype.hasOwnProperty;
-	var bind = requireFunctionBind();
-
-	/** @type {import('.')} */
-	hasown = bind.call(call, $hasOwn);
-	return hasown;
-}
+/** @type {import('.')} */
+var hasown = bind$1.call(call, $hasOwn);
 
 var undefined$1;
 
@@ -12957,7 +12966,7 @@ var $URIError = uri;
 
 var abs = abs$1;
 var floor = floor$1;
-var max = max$1;
+var max = max$2;
 var min = min$1;
 var pow = pow$1;
 var round = round$1;
@@ -13183,8 +13192,8 @@ var LEGACY_ALIASES = {
 	'%WeakSetPrototype%': ['WeakSet', 'prototype']
 };
 
-var bind = requireFunctionBind();
-var hasOwn$1 = requireHasown();
+var bind = functionBind;
+var hasOwn$2 = hasown;
 var $concat = bind.call($call, Array.prototype.concat);
 var $spliceApply = bind.call($apply, Array.prototype.splice);
 var $replace = bind.call($call, String.prototype.replace);
@@ -13213,12 +13222,12 @@ var stringToPath = function stringToPath(string) {
 var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
 	var intrinsicName = name;
 	var alias;
-	if (hasOwn$1(LEGACY_ALIASES, intrinsicName)) {
+	if (hasOwn$2(LEGACY_ALIASES, intrinsicName)) {
 		alias = LEGACY_ALIASES[intrinsicName];
 		intrinsicName = '%' + alias[0] + '%';
 	}
 
-	if (hasOwn$1(INTRINSICS, intrinsicName)) {
+	if (hasOwn$2(INTRINSICS, intrinsicName)) {
 		var value = INTRINSICS[intrinsicName];
 		if (value === needsEval) {
 			value = doEval(intrinsicName);
@@ -13282,14 +13291,14 @@ var getIntrinsic = function GetIntrinsic(name, allowMissing) {
 		intrinsicBaseName += '.' + part;
 		intrinsicRealName = '%' + intrinsicBaseName + '%';
 
-		if (hasOwn$1(INTRINSICS, intrinsicRealName)) {
+		if (hasOwn$2(INTRINSICS, intrinsicRealName)) {
 			value = INTRINSICS[intrinsicRealName];
 		} else if (value != null) {
 			if (!(part in value)) {
 				if (!allowMissing) {
 					throw new $TypeError$1('base intrinsic for ' + name + ' exists, but the property is not available.');
 				}
-				return void 0;
+				return void undefined$1;
 			}
 			if ($gOPD && (i + 1) >= parts.length) {
 				var desc = $gOPD(value, part);
@@ -13308,7 +13317,7 @@ var getIntrinsic = function GetIntrinsic(name, allowMissing) {
 					value = value[part];
 				}
 			} else {
-				isOwn = hasOwn$1(value, part);
+				isOwn = hasOwn$2(value, part);
 				value = value[part];
 			}
 
@@ -13341,7 +13350,7 @@ var GetIntrinsic = getIntrinsic;
 var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
 
 var hasToStringTag = requireShams()();
-var hasOwn = requireHasown();
+var hasOwn$1 = hasown;
 var $TypeError = requireType();
 
 var toStringTag = hasToStringTag ? Symbol.toStringTag : null;
@@ -13356,7 +13365,7 @@ var esSetTostringtag = function setToStringTag(object, value) {
 	) {
 		throw new $TypeError('if provided, the `overrideIfSet` and `nonConfigurable` options must be booleans');
 	}
-	if (toStringTag && (overrideIfSet || !hasOwn(object, toStringTag))) {
+	if (toStringTag && (overrideIfSet || !hasOwn$1(object, toStringTag))) {
 		if ($defineProperty) {
 			$defineProperty(object, toStringTag, {
 				configurable: !nonConfigurable,
@@ -13371,11 +13380,9 @@ var esSetTostringtag = function setToStringTag(object, value) {
 };
 
 // populates missing values
-var populate$1 = function(dst, src) {
-
-  Object.keys(src).forEach(function(prop)
-  {
-    dst[prop] = dst[prop] || src[prop];
+var populate$1 = function (dst, src) {
+  Object.keys(src).forEach(function (prop) {
+    dst[prop] = dst[prop] || src[prop]; // eslint-disable-line no-param-reassign
   });
 
   return dst;
@@ -13389,24 +13396,20 @@ var https$1 = require$$4;
 var parseUrl$2 = require$$0$1.parse;
 var fs = require$$6;
 var Stream = stream.Stream;
+var crypto = require$$8;
 var mime = mimeTypes;
 var asynckit = asynckit$1;
 var setToStringTag = esSetTostringtag;
+var hasOwn = hasown;
 var populate = populate$1;
 
-// Public API
-var form_data = FormData$1;
-
-// make it a Stream
-util.inherits(FormData$1, CombinedStream);
-
 /**
  * Create readable "multipart/form-data" streams.
  * Can be used to submit forms
  * and file uploads to other web applications.
  *
  * @constructor
- * @param {Object} options - Properties to be added/overriden for FormData and CombinedStream
+ * @param {object} options - Properties to be added/overriden for FormData and CombinedStream
  */
 function FormData$1(options) {
   if (!(this instanceof FormData$1)) {
@@ -13419,35 +13422,39 @@ function FormData$1(options) {
 
   CombinedStream.call(this);
 
-  options = options || {};
-  for (var option in options) {
+  options = options || {}; // eslint-disable-line no-param-reassign
+  for (var option in options) { // eslint-disable-line no-restricted-syntax
     this[option] = options[option];
   }
 }
 
+// make it a Stream
+util.inherits(FormData$1, CombinedStream);
+
 FormData$1.LINE_BREAK = '\r\n';
 FormData$1.DEFAULT_CONTENT_TYPE = 'application/octet-stream';
 
-FormData$1.prototype.append = function(field, value, options) {
-
-  options = options || {};
+FormData$1.prototype.append = function (field, value, options) {
+  options = options || {}; // eslint-disable-line no-param-reassign
 
   // allow filename as single option
-  if (typeof options == 'string') {
-    options = {filename: options};
+  if (typeof options === 'string') {
+    options = { filename: options }; // eslint-disable-line no-param-reassign
   }
 
   var append = CombinedStream.prototype.append.bind(this);
 
   // all that streamy business can't handle numbers
-  if (typeof value == 'number') {
-    value = '' + value;
+  if (typeof value === 'number' || value == null) {
+    value = String(value); // eslint-disable-line no-param-reassign
   }
 
   // https://github.com/felixge/node-form-data/issues/38
   if (Array.isArray(value)) {
-    // Please convert your array into string
-    // the way web server expects it
+    /*
+     * Please convert your array into string
+     * the way web server expects it
+     */
     this._error(new Error('Arrays are not supported.'));
     return;
   }
@@ -13463,15 +13470,17 @@ FormData$1.prototype.append = function(field, value, options) {
   this._trackLength(header, value, options);
 };
 
-FormData$1.prototype._trackLength = function(header, value, options) {
+FormData$1.prototype._trackLength = function (header, value, options) {
   var valueLength = 0;
 
-  // used w/ getLengthSync(), when length is known.
-  // e.g. for streaming directly from a remote server,
-  // w/ a known file a size, and not wanting to wait for
-  // incoming file to finish to get its size.
+  /*
+   * used w/ getLengthSync(), when length is known.
+   * e.g. for streaming directly from a remote server,
+   * w/ a known file a size, and not wanting to wait for
+   * incoming file to finish to get its size.
+   */
   if (options.knownLength != null) {
-    valueLength += +options.knownLength;
+    valueLength += Number(options.knownLength);
   } else if (Buffer.isBuffer(value)) {
     valueLength = value.length;
   } else if (typeof value === 'string') {
@@ -13481,12 +13490,10 @@ FormData$1.prototype._trackLength = function(header, value, options) {
   this._valueLength += valueLength;
 
   // @check why add CRLF? does this account for custom/multiple CRLFs?
-  this._overheadLength +=
-    Buffer.byteLength(header) +
-    FormData$1.LINE_BREAK.length;
+  this._overheadLength += Buffer.byteLength(header) + FormData$1.LINE_BREAK.length;
 
   // empty or either doesn't have path or not an http response or not a stream
-  if (!value || ( !value.path && !(value.readable && Object.prototype.hasOwnProperty.call(value, 'httpVersion')) && !(value instanceof Stream))) {
+  if (!value || (!value.path && !(value.readable && hasOwn(value, 'httpVersion')) && !(value instanceof Stream))) {
     return;
   }
 
@@ -13496,9 +13503,8 @@ FormData$1.prototype._trackLength = function(header, value, options) {
   }
 };
 
-FormData$1.prototype._lengthRetriever = function(value, callback) {
-  if (Object.prototype.hasOwnProperty.call(value, 'fd')) {
-
+FormData$1.prototype._lengthRetriever = function (value, callback) {
+  if (hasOwn(value, 'fd')) {
     // take read range into a account
     // `end` = Infinity –> read file till the end
     //
@@ -13507,54 +13513,52 @@ FormData$1.prototype._lengthRetriever = function(value, callback) {
     // Fix it when node fixes it.
     // https://github.com/joyent/node/issues/7819
     if (value.end != undefined && value.end != Infinity && value.start != undefined) {
-
       // when end specified
       // no need to calculate range
       // inclusive, starts with 0
-      callback(null, value.end + 1 - (value.start ? value.start : 0));
+      callback(null, value.end + 1 - (value.start ? value.start : 0)); // eslint-disable-line callback-return
 
-    // not that fast snoopy
+      // not that fast snoopy
     } else {
       // still need to fetch file size from fs
-      fs.stat(value.path, function(err, stat) {
-
-        var fileSize;
-
+      fs.stat(value.path, function (err, stat) {
         if (err) {
           callback(err);
           return;
         }
 
         // update final size based on the range options
-        fileSize = stat.size - (value.start ? value.start : 0);
+        var fileSize = stat.size - (value.start ? value.start : 0);
         callback(null, fileSize);
       });
     }
 
-  // or http response
-  } else if (Object.prototype.hasOwnProperty.call(value, 'httpVersion')) {
-    callback(null, +value.headers['content-length']);
+    // or http response
+  } else if (hasOwn(value, 'httpVersion')) {
+    callback(null, Number(value.headers['content-length'])); // eslint-disable-line callback-return
 
-  // or request stream http://github.com/mikeal/request
-  } else if (Object.prototype.hasOwnProperty.call(value, 'httpModule')) {
+    // or request stream http://github.com/mikeal/request
+  } else if (hasOwn(value, 'httpModule')) {
     // wait till response come back
-    value.on('response', function(response) {
+    value.on('response', function (response) {
       value.pause();
-      callback(null, +response.headers['content-length']);
+      callback(null, Number(response.headers['content-length']));
     });
     value.resume();
 
-  // something else
+    // something else
   } else {
-    callback('Unknown stream');
+    callback('Unknown stream'); // eslint-disable-line callback-return
   }
 };
 
-FormData$1.prototype._multiPartHeader = function(field, value, options) {
-  // custom header specified (as string)?
-  // it becomes responsible for boundary
-  // (e.g. to handle extra CRLFs on .NET servers)
-  if (typeof options.header == 'string') {
+FormData$1.prototype._multiPartHeader = function (field, value, options) {
+  /*
+   * custom header specified (as string)?
+   * it becomes responsible for boundary
+   * (e.g. to handle extra CRLFs on .NET servers)
+   */
+  if (typeof options.header === 'string') {
     return options.header;
   }
 
@@ -13562,7 +13566,7 @@ FormData$1.prototype._multiPartHeader = function(field, value, options) {
   var contentType = this._getContentType(value, options);
 
   var contents = '';
-  var headers  = {
+  var headers = {
     // add custom disposition as third element or keep it two elements if not
     'Content-Disposition': ['form-data', 'name="' + field + '"'].concat(contentDisposition || []),
     // if no content type. allow it to be empty array
@@ -13570,18 +13574,18 @@ FormData$1.prototype._multiPartHeader = function(field, value, options) {
   };
 
   // allow custom headers.
-  if (typeof options.header == 'object') {
+  if (typeof options.header === 'object') {
     populate(headers, options.header);
   }
 
   var header;
-  for (var prop in headers) {
-    if (Object.prototype.hasOwnProperty.call(headers, prop)) {
+  for (var prop in headers) { // eslint-disable-line no-restricted-syntax
+    if (hasOwn(headers, prop)) {
       header = headers[prop];
 
       // skip nullish headers.
       if (header == null) {
-        continue;
+        continue; // eslint-disable-line no-restricted-syntax, no-continue
       }
 
       // convert all headers to arrays.
@@ -13599,49 +13603,45 @@ FormData$1.prototype._multiPartHeader = function(field, value, options) {
   return '--' + this.getBoundary() + FormData$1.LINE_BREAK + contents + FormData$1.LINE_BREAK;
 };
 
-FormData$1.prototype._getContentDisposition = function(value, options) {
-
-  var filename
-    , contentDisposition
-    ;
+FormData$1.prototype._getContentDisposition = function (value, options) { // eslint-disable-line consistent-return
+  var filename;
 
   if (typeof options.filepath === 'string') {
     // custom filepath for relative paths
     filename = path.normalize(options.filepath).replace(/\\/g, '/');
-  } else if (options.filename || value.name || value.path) {
-    // custom filename take precedence
-    // formidable and the browser add a name property
-    // fs- and request- streams have path property
-    filename = path.basename(options.filename || value.name || value.path);
-  } else if (value.readable && Object.prototype.hasOwnProperty.call(value, 'httpVersion')) {
+  } else if (options.filename || (value && (value.name || value.path))) {
+    /*
+     * custom filename take precedence
+     * formidable and the browser add a name property
+     * fs- and request- streams have path property
+     */
+    filename = path.basename(options.filename || (value && (value.name || value.path)));
+  } else if (value && value.readable && hasOwn(value, 'httpVersion')) {
     // or try http response
     filename = path.basename(value.client._httpMessage.path || '');
   }
 
   if (filename) {
-    contentDisposition = 'filename="' + filename + '"';
+    return 'filename="' + filename + '"';
   }
-
-  return contentDisposition;
 };
 
-FormData$1.prototype._getContentType = function(value, options) {
-
+FormData$1.prototype._getContentType = function (value, options) {
   // use custom content-type above all
   var contentType = options.contentType;
 
   // or try `name` from formidable, browser
-  if (!contentType && value.name) {
+  if (!contentType && value && value.name) {
     contentType = mime.lookup(value.name);
   }
 
   // or try `path` from fs-, request- streams
-  if (!contentType && value.path) {
+  if (!contentType && value && value.path) {
     contentType = mime.lookup(value.path);
   }
 
   // or if it's http-reponse
-  if (!contentType && value.readable && Object.prototype.hasOwnProperty.call(value, 'httpVersion')) {
+  if (!contentType && value && value.readable && hasOwn(value, 'httpVersion')) {
     contentType = value.headers['content-type'];
   }
 
@@ -13651,18 +13651,18 @@ FormData$1.prototype._getContentType = function(value, options) {
   }
 
   // fallback to the default content type if `value` is not simple value
-  if (!contentType && typeof value == 'object') {
+  if (!contentType && value && typeof value === 'object') {
     contentType = FormData$1.DEFAULT_CONTENT_TYPE;
   }
 
   return contentType;
 };
 
-FormData$1.prototype._multiPartFooter = function() {
-  return function(next) {
+FormData$1.prototype._multiPartFooter = function () {
+  return function (next) {
     var footer = FormData$1.LINE_BREAK;
 
-    var lastPart = (this._streams.length === 0);
+    var lastPart = this._streams.length === 0;
     if (lastPart) {
       footer += this._lastBoundary();
     }
@@ -13671,18 +13671,18 @@ FormData$1.prototype._multiPartFooter = function() {
   }.bind(this);
 };
 
-FormData$1.prototype._lastBoundary = function() {
+FormData$1.prototype._lastBoundary = function () {
   return '--' + this.getBoundary() + '--' + FormData$1.LINE_BREAK;
 };
 
-FormData$1.prototype.getHeaders = function(userHeaders) {
+FormData$1.prototype.getHeaders = function (userHeaders) {
   var header;
   var formHeaders = {
     'content-type': 'multipart/form-data; boundary=' + this.getBoundary()
   };
 
-  for (header in userHeaders) {
-    if (Object.prototype.hasOwnProperty.call(userHeaders, header)) {
+  for (header in userHeaders) { // eslint-disable-line no-restricted-syntax
+    if (hasOwn(userHeaders, header)) {
       formHeaders[header.toLowerCase()] = userHeaders[header];
     }
   }
@@ -13690,11 +13690,14 @@ FormData$1.prototype.getHeaders = function(userHeaders) {
   return formHeaders;
 };
 
-FormData$1.prototype.setBoundary = function(boundary) {
+FormData$1.prototype.setBoundary = function (boundary) {
+  if (typeof boundary !== 'string') {
+    throw new TypeError('FormData boundary must be a string');
+  }
   this._boundary = boundary;
 };
 
-FormData$1.prototype.getBoundary = function() {
+FormData$1.prototype.getBoundary = function () {
   if (!this._boundary) {
     this._generateBoundary();
   }
@@ -13702,60 +13705,55 @@ FormData$1.prototype.getBoundary = function() {
   return this._boundary;
 };
 
-FormData$1.prototype.getBuffer = function() {
-  var dataBuffer = new Buffer.alloc(0);
+FormData$1.prototype.getBuffer = function () {
+  var dataBuffer = new Buffer.alloc(0); // eslint-disable-line new-cap
   var boundary = this.getBoundary();
 
   // Create the form content. Add Line breaks to the end of data.
   for (var i = 0, len = this._streams.length; i < len; i++) {
     if (typeof this._streams[i] !== 'function') {
-
       // Add content to the buffer.
-      if(Buffer.isBuffer(this._streams[i])) {
-        dataBuffer = Buffer.concat( [dataBuffer, this._streams[i]]);
-      }else {
-        dataBuffer = Buffer.concat( [dataBuffer, Buffer.from(this._streams[i])]);
+      if (Buffer.isBuffer(this._streams[i])) {
+        dataBuffer = Buffer.concat([dataBuffer, this._streams[i]]);
+      } else {
+        dataBuffer = Buffer.concat([dataBuffer, Buffer.from(this._streams[i])]);
       }
 
       // Add break after content.
-      if (typeof this._streams[i] !== 'string' || this._streams[i].substring( 2, boundary.length + 2 ) !== boundary) {
-        dataBuffer = Buffer.concat( [dataBuffer, Buffer.from(FormData$1.LINE_BREAK)] );
+      if (typeof this._streams[i] !== 'string' || this._streams[i].substring(2, boundary.length + 2) !== boundary) {
+        dataBuffer = Buffer.concat([dataBuffer, Buffer.from(FormData$1.LINE_BREAK)]);
       }
     }
   }
 
   // Add the footer and return the Buffer object.
-  return Buffer.concat( [dataBuffer, Buffer.from(this._lastBoundary())] );
+  return Buffer.concat([dataBuffer, Buffer.from(this._lastBoundary())]);
 };
 
-FormData$1.prototype._generateBoundary = function() {
+FormData$1.prototype._generateBoundary = function () {
   // This generates a 50 character boundary similar to those used by Firefox.
-  // They are optimized for boyer-moore parsing.
-  var boundary = '--------------------------';
-  for (var i = 0; i < 24; i++) {
-    boundary += Math.floor(Math.random() * 10).toString(16);
-  }
 
-  this._boundary = boundary;
+  // They are optimized for boyer-moore parsing.
+  this._boundary = '--------------------------' + crypto.randomBytes(12).toString('hex');
 };
 
 // Note: getLengthSync DOESN'T calculate streams length
-// As workaround one can calculate file size manually
-// and add it as knownLength option
-FormData$1.prototype.getLengthSync = function() {
+// As workaround one can calculate file size manually and add it as knownLength option
+FormData$1.prototype.getLengthSync = function () {
   var knownLength = this._overheadLength + this._valueLength;
 
-  // Don't get confused, there are 3 "internal" streams for each keyval pair
-  // so it basically checks if there is any value added to the form
+  // Don't get confused, there are 3 "internal" streams for each keyval pair so it basically checks if there is any value added to the form
   if (this._streams.length) {
     knownLength += this._lastBoundary().length;
   }
 
   // https://github.com/form-data/form-data/issues/40
   if (!this.hasKnownLength()) {
-    // Some async length retrievers are present
-    // therefore synchronous length calculation is false.
-    // Please use getLength(callback) to get proper length
+    /*
+     * Some async length retrievers are present
+     * therefore synchronous length calculation is false.
+     * Please use getLength(callback) to get proper length
+     */
     this._error(new Error('Cannot calculate proper length in synchronous way.'));
   }
 
@@ -13765,7 +13763,7 @@ FormData$1.prototype.getLengthSync = function() {
 // Public API to check if length of added values is known
 // https://github.com/form-data/form-data/issues/196
 // https://github.com/form-data/form-data/issues/262
-FormData$1.prototype.hasKnownLength = function() {
+FormData$1.prototype.hasKnownLength = function () {
   var hasKnownLength = true;
 
   if (this._valuesToMeasure.length) {
@@ -13775,7 +13773,7 @@ FormData$1.prototype.hasKnownLength = function() {
   return hasKnownLength;
 };
 
-FormData$1.prototype.getLength = function(cb) {
+FormData$1.prototype.getLength = function (cb) {
   var knownLength = this._overheadLength + this._valueLength;
 
   if (this._streams.length) {
@@ -13787,13 +13785,13 @@ FormData$1.prototype.getLength = function(cb) {
     return;
   }
 
-  asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
+  asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function (err, values) {
     if (err) {
       cb(err);
       return;
     }
 
-    values.forEach(function(length) {
+    values.forEach(function (length) {
       knownLength += length;
     });
 
@@ -13801,31 +13799,26 @@ FormData$1.prototype.getLength = function(cb) {
   });
 };
 
-FormData$1.prototype.submit = function(params, cb) {
-  var request
-    , options
-    , defaults = {method: 'post'}
-    ;
-
-  // parse provided url if it's string
-  // or treat it as options object
-  if (typeof params == 'string') {
+FormData$1.prototype.submit = function (params, cb) {
+  var request;
+  var options;
+  var defaults = { method: 'post' };
 
-    params = parseUrl$2(params);
+  // parse provided url if it's string or treat it as options object
+  if (typeof params === 'string') {
+    params = parseUrl$2(params); // eslint-disable-line no-param-reassign
+    /* eslint sort-keys: 0 */
     options = populate({
       port: params.port,
       path: params.pathname,
       host: params.hostname,
       protocol: params.protocol
     }, defaults);
-
-  // use custom params
-  } else {
-
+  } else { // use custom params
     options = populate(params, defaults);
     // if no port provided use default one
     if (!options.port) {
-      options.port = options.protocol == 'https:' ? 443 : 80;
+      options.port = options.protocol === 'https:' ? 443 : 80;
     }
   }
 
@@ -13833,14 +13826,14 @@ FormData$1.prototype.submit = function(params, cb) {
   options.headers = this.getHeaders(params.headers);
 
   // https if specified, fallback to http in any other case
-  if (options.protocol == 'https:') {
+  if (options.protocol === 'https:') {
     request = https$1.request(options);
   } else {
     request = http$1.request(options);
   }
 
   // get content length and fire away
-  this.getLength(function(err, length) {
+  this.getLength(function (err, length) {
     if (err && err !== 'Unknown stream') {
       this._error(err);
       return;
@@ -13859,7 +13852,7 @@ FormData$1.prototype.submit = function(params, cb) {
         request.removeListener('error', callback);
         request.removeListener('response', onResponse);
 
-        return cb.call(this, error, responce);
+        return cb.call(this, error, responce); // eslint-disable-line no-invalid-this
       };
 
       onResponse = callback.bind(this, null);
@@ -13872,7 +13865,7 @@ FormData$1.prototype.submit = function(params, cb) {
   return request;
 };
 
-FormData$1.prototype._error = function(err) {
+FormData$1.prototype._error = function (err) {
   if (!this.error) {
     this.error = err;
     this.pause();
@@ -13885,6 +13878,9 @@ FormData$1.prototype.toString = function () {
 };
 setToStringTag(FormData$1, 'FormData');
 
+// Public API
+var form_data = FormData$1;
+
 var FormData$2 = /*@__PURE__*/getDefaultExportFromCjs(form_data);
 
 /**
@@ -14002,6 +13998,10 @@ function toFormData$1(obj, formData, options) {
       return value.toISOString();
     }
 
+    if (utils$1.isBoolean(value)) {
+      return value.toString();
+    }
+
     if (!useBlob && utils$1.isBlob(value)) {
       throw new AxiosError$1('Blob is not supported. Use a Buffer instead.');
     }
@@ -14304,7 +14304,7 @@ const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
   let str = '';
   const {length} = alphabet;
   const randomValues = new Uint32Array(size);
-  crypto.randomFillSync(randomValues);
+  require$$8.randomFillSync(randomValues);
   for (let i = 0; i < size; i++) {
     str += alphabet[randomValues[i] % length];
   }
@@ -14384,7 +14384,7 @@ var platform = {
 };
 
 function toURLEncodedForm(data, options) {
-  return toFormData$1(data, new platform.classes.URLSearchParams(), Object.assign({
+  return toFormData$1(data, new platform.classes.URLSearchParams(), {
     visitor: function(value, key, path, helpers) {
       if (platform.isNode && utils$1.isBuffer(value)) {
         this.append(key, value.toString('base64'));
@@ -14392,8 +14392,9 @@ function toURLEncodedForm(data, options) {
       }
 
       return helpers.defaultVisitor.apply(this, arguments);
-    }
-  }, options));
+    },
+    ...options
+  });
 }
 
 /**
@@ -15929,7 +15930,7 @@ followRedirects$1.exports.wrap = wrap;
 var followRedirectsExports = followRedirects$1.exports;
 var followRedirects = /*@__PURE__*/getDefaultExportFromCjs(followRedirectsExports);
 
-const VERSION$1 = "1.9.0";
+const VERSION$1 = "1.11.0";
 
 function parseProtocol(url) {
   const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
@@ -16347,7 +16348,7 @@ function throttle(fn, freq) {
       clearTimeout(timer);
       timer = null;
     }
-    fn.apply(null, args);
+    fn(...args);
   };
 
   const throttled = (...args) => {
@@ -17221,7 +17222,7 @@ function mergeConfig$1(config1, config2) {
     headers: (a, b , prop) => mergeDeepProperties(headersToObject(a), headersToObject(b),prop, true)
   };
 
-  utils$1.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
+  utils$1.forEach(Object.keys({...config1, ...config2}), function computeConfigValue(prop) {
     const merge = mergeMap[prop] || mergeDeepProperties;
     const configValue = merge(config1[prop], config2[prop], prop);
     (utils$1.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
@@ -17754,7 +17755,7 @@ var fetchAdapter = isFetchSupported && (async (config) => {
       credentials: isCredentialsSupported ? withCredentials : undefined
     });
 
-    let response = await fetch(request);
+    let response = await fetch(request, fetchOptions);
 
     const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
 
@@ -18197,8 +18198,8 @@ let Axios$1 = class Axios {
 
     if (!synchronousRequestInterceptors) {
       const chain = [dispatchRequest.bind(this), undefined];
-      chain.unshift.apply(chain, requestInterceptorChain);
-      chain.push.apply(chain, responseInterceptorChain);
+      chain.unshift(...requestInterceptorChain);
+      chain.push(...responseInterceptorChain);
       len = chain.length;
 
       promise = Promise.resolve(config);
@@ -18530,7 +18531,7 @@ Object.entries(HttpStatusCode$1).forEach(([key, value]) => {
  */
 function createInstance(defaultConfig) {
   const context = new Axios$1(defaultConfig);
-  const instance = bind$1(Axios$1.prototype.request, context);
+  const instance = bind$2(Axios$1.prototype.request, context);
 
   // Copy axios.prototype to instance
   utils$1.extend(instance, Axios$1.prototype, context, {allOwnKeys: true});
@@ -19164,5 +19165,557 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
     };
 }
 
-export { GENESIS_TIMESTAMP, createWeeklyReport, createWeeklyReportLegacy };
+const FORWARDER_ABI = [
+    {
+        inputs: [{ internalType: "address", name: "_forwarder", type: "address" }],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    {
+        inputs: [{ internalType: "address", name: "target", type: "address" }],
+        name: "AddressEmptyCode",
+        type: "error",
+    },
+    {
+        inputs: [{ internalType: "address", name: "account", type: "address" }],
+        name: "AddressInsufficientBalance",
+        type: "error",
+    },
+    { inputs: [], name: "FailedInnerCall", type: "error" },
+    {
+        inputs: [{ internalType: "address", name: "token", type: "address" }],
+        name: "SafeERC20FailedOperation",
+        type: "error",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "address", name: "from", type: "address" },
+            { indexed: true, internalType: "address", name: "to", type: "address" },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "token",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "amount",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "string",
+                name: "message",
+                type: "string",
+            },
+        ],
+        name: "Forward",
+        type: "event",
+    },
+    {
+        inputs: [],
+        name: "FORWARD_ADDRESS",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "token", type: "address" },
+            { internalType: "address", name: "to", type: "address" },
+            { internalType: "uint256", name: "amount", type: "uint256" },
+            { internalType: "string", name: "message", type: "string" },
+        ],
+        name: "forward",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+];
+
+const ERC20_ABI = [
+    {
+        inputs: [
+            { name: "spender", type: "address" },
+            { name: "amount", type: "uint256" },
+        ],
+        name: "approve",
+        outputs: [{ name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { name: "owner", type: "address" },
+            { name: "spender", type: "address" },
+        ],
+        name: "allowance",
+        outputs: [{ name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { name: "to", type: "address" },
+            { name: "amount", type: "uint256" },
+        ],
+        name: "transfer",
+        outputs: [{ name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ name: "account", type: "address" }],
+        name: "balanceOf",
+        outputs: [{ name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { name: "account", type: "address" },
+            { name: "amount", type: "uint256" },
+        ],
+        name: "mint",
+        outputs: [{ name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+];
+
+// Contract-specific addresses
+const mainnetAddresses = {
+    USDG: "0xe010ec500720bE9EF3F82129E7eD2Ee1FB7955F2",
+    GLW: "0xf4fbC617A5733EAAF9af08E1Ab816B103388d8B6",
+    USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    FORWARDER: "0x0000000000000000000000000000000000000000", // TODO: Update with actual mainnet address
+    FOUNDATION_WALLET: "0x0000000000000000000000000000000000000000", // TODO: Update with actual mainnet foundation wallet
+};
+const sepoliaAddresses = {
+    USDG: "0xda78313A3fF949890112c1B746AB1c75d1b1c17B",
+    GLW: "0x2039161fcE4C8e5CF5FE64e17Fd290E8dFF3c9BD",
+    USDC: "0x93c898be98cd2618ba84a6dccf5003d3bbe40356",
+    FORWARDER: "0x9c1d61303D46BFAb1eC5F25c12A1Bf4cB3d06416",
+    FOUNDATION_WALLET: "0x5e230FED487c86B90f6508104149F087d9B1B0A7",
+};
+const getAddresses = (CHAIN_ID) => {
+    switch (CHAIN_ID) {
+        case 1:
+            return mainnetAddresses;
+        case 11155111:
+            return sepoliaAddresses;
+        default:
+            console.warn(`Unsupported chain ID: ${CHAIN_ID}, falling back to mainnet addresses`);
+            return mainnetAddresses;
+    }
+};
+
+var ForwarderError;
+(function (ForwarderError) {
+    ForwarderError["CONTRACT_NOT_AVAILABLE"] = "Contract not available";
+    ForwarderError["SIGNER_NOT_AVAILABLE"] = "Signer not available";
+    ForwarderError["UNKNOWN_ERROR"] = "Unknown error";
+    ForwarderError["INVALID_FORWARD_TYPE"] = "Invalid forward type";
+    ForwarderError["MISSING_REQUIRED_PARAMS"] = "Missing required parameters";
+})(ForwarderError || (ForwarderError = {}));
+// Utility to extract the most useful revert reason from an ethers error object
+function parseEthersError(error) {
+    if (!error)
+        return "Unknown error";
+    const possibleError = error;
+    // If the error originates from a callStatic it will often be found at `error?.error?.body`
+    if (possibleError?.error?.body) {
+        try {
+            const body = JSON.parse(possibleError.error.body);
+            // Hardhat style errors
+            if (body?.error?.message)
+                return body.error.message;
+        }
+        catch { }
+    }
+    // Found on MetaMask/Alchemy shape errors
+    if (possibleError?.data?.message)
+        return possibleError.data.message;
+    if (possibleError?.error?.message)
+        return possibleError.error.message;
+    // Standard ethers v5 message
+    if (possibleError?.reason)
+        return possibleError.reason;
+    if (possibleError?.message)
+        return possibleError.message;
+    return ForwarderError.UNKNOWN_ERROR;
+}
+// Type-guard style helper to ensure a signer exists throughout the rest of the function.
+function assertSigner(maybeSigner) {
+    if (!maybeSigner) {
+        throw new Error(ForwarderError.SIGNER_NOT_AVAILABLE);
+    }
+}
+function useForwarder(signer, CHAIN_ID) {
+    // Use dynamic addresses based on chain configuration
+    const ADDRESSES = getAddresses(CHAIN_ID);
+    // Framework-agnostic processing flag
+    let isProcessing = false;
+    const setIsProcessing = (value) => {
+        isProcessing = value;
+    };
+    // Returns a contract instance for Forwarder
+    function getForwarderContract() {
+        assertSigner(signer);
+        return new ethers.Contract(ADDRESSES.FORWARDER, FORWARDER_ABI, signer);
+    }
+    /**
+     * Construct the message for the forward call based on type and parameters
+     */
+    function constructForwardMessage(params) {
+        const { type, applicationId, farmId, regionId, userAddress } = params;
+        switch (type) {
+            case "PayProtocolFeeAndMintGCTLAndStake":
+                if (!applicationId) {
+                    throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
+                }
+                return `PayProtocolFeeAndMintGCTLAndStake::${applicationId}`;
+            case "PayProtocolFee":
+                if (!applicationId) {
+                    throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
+                }
+                return `PayProtocolFee::${applicationId}`;
+            case "MintGCTLAndStake":
+                if (!regionId) {
+                    throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
+                }
+                return `MintGCTLAndStake::${regionId}`;
+            case "MintGCTL":
+                if (!userAddress) {
+                    throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
+                }
+                return `MintGCTL::${userAddress}`;
+            case "BuySolarFarm":
+                if (!farmId) {
+                    throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
+                }
+                return `BuySolarFarm::${farmId}`;
+            default:
+                throw new Error(ForwarderError.INVALID_FORWARD_TYPE);
+        }
+    }
+    /**
+     * Get the appropriate token contract based on currency
+     */
+    function getTokenContract(currency = "USDC") {
+        assertSigner(signer);
+        let tokenAddress;
+        switch (currency) {
+            case "USDC":
+                tokenAddress = ADDRESSES.USDC;
+                break;
+            case "GLW":
+                tokenAddress = ADDRESSES.GLW;
+                break;
+            case "USDG":
+                tokenAddress = ADDRESSES.USDG;
+                break;
+            default:
+                throw new Error(`Currency ${currency} not yet supported. Only USDC, GLW, and USDG are currently supported.`);
+        }
+        return new ethers.Contract(tokenAddress, ERC20_ABI, signer);
+    }
+    /**
+     * Check current token allowance for the forwarder contract
+     * @param owner The wallet address to check allowance for
+     * @param currency The currency to check allowance for
+     */
+    async function checkTokenAllowance(owner, currency = "USDC") {
+        assertSigner(signer);
+        try {
+            const tokenContract = getTokenContract(currency);
+            if (!tokenContract)
+                throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+            const allowance = await tokenContract.allowance(owner, ADDRESSES.FORWARDER);
+            return allowance;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * Check user's token balance
+     * @param owner The wallet address to check balance for
+     * @param currency The currency to check balance for
+     */
+    async function checkTokenBalance(owner, currency = "USDC") {
+        assertSigner(signer);
+        try {
+            const tokenContract = getTokenContract(currency);
+            if (!tokenContract)
+                throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+            const balance = await tokenContract.balanceOf(owner);
+            return balance;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * Approve tokens for the forwarder contract
+     * @param amount Amount to approve (BigNumber)
+     * @param currency The currency to approve
+     */
+    async function approveToken(amount, currency = "USDC") {
+        assertSigner(signer);
+        try {
+            const tokenContract = getTokenContract(currency);
+            if (!tokenContract)
+                throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+            setIsProcessing(true);
+            // Approve only the specific amount needed
+            const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, amount);
+            await approveTx.wait();
+            return true;
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * Forward tokens through the forwarder contract with type-specific handling
+     * @param params Forward parameters including type, amount, and required fields
+     */
+    async function forwardTokens(params) {
+        assertSigner(signer);
+        try {
+            const forwarderContract = getForwarderContract();
+            if (!forwarderContract)
+                throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+            setIsProcessing(true);
+            const { amount, currency = "USDC" } = params;
+            const tokenContract = getTokenContract(currency);
+            if (!tokenContract)
+                throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+            const owner = await signer.getAddress();
+            // Construct the appropriate message for this forward type
+            const message = constructForwardMessage(params);
+            // Check allowance and approve if necessary
+            const allowance = await tokenContract.allowance(owner, ADDRESSES.FORWARDER);
+            if (allowance.lt(amount)) {
+                try {
+                    const approveTx = await tokenContract.approve(ADDRESSES.FORWARDER, ethers.constants.MaxUint256);
+                    await approveTx.wait();
+                }
+                catch (approveError) {
+                    throw new Error(parseEthersError(approveError) || "Token approval failed");
+                }
+            }
+            // Get the token address based on currency
+            let tokenAddress;
+            switch (currency) {
+                case "USDC":
+                    tokenAddress = ADDRESSES.USDC;
+                    break;
+                case "USDG":
+                    tokenAddress = ADDRESSES.USDG;
+                    break;
+                case "GLW":
+                    tokenAddress = ADDRESSES.GLW;
+                    break;
+                default:
+                    throw new Error(`Unsupported currency for forwarding: ${currency}`);
+            }
+            // Run a static call first to surface any revert reason
+            try {
+                await forwarderContract.callStatic.forward(tokenAddress, ADDRESSES.FOUNDATION_WALLET, amount, message, { from: owner });
+            }
+            catch (staticError) {
+                throw new Error(parseEthersError(staticError));
+            }
+            // Execute the forward transaction
+            const tx = await forwarderContract.forward(tokenAddress, ADDRESSES.FOUNDATION_WALLET, amount, message);
+            await tx.wait();
+            return tx.hash;
+        }
+        catch (txError) {
+            throw new Error(parseEthersError(txError));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * Forward tokens for protocol fee payment and GCTL minting with staking
+     */
+    async function payProtocolFeeAndMintGCTLAndStake(amount, userAddress, applicationId, regionId, currency = "USDC") {
+        assertSigner(signer);
+        // GCTL minting only supports USDC and USDG
+        if (currency === "GLW") {
+            throw new Error("GCTL minting is not supported with GLW payment. Use USDC or USDG.");
+        }
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: "PayProtocolFeeAndMintGCTLAndStake",
+            currency,
+            applicationId,
+            regionId,
+        });
+    }
+    /**
+     * Forward tokens for protocol fee payment only
+     */
+    async function payProtocolFee(amount, userAddress, applicationId, currency = "USDC") {
+        assertSigner(signer);
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: "PayProtocolFee",
+            currency,
+            applicationId,
+        });
+    }
+    /**
+     * Forward USDC to mint GCTL and stake to a region
+     */
+    async function mintGCTLAndStake(amount, userAddress, regionId) {
+        assertSigner(signer);
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: "MintGCTLAndStake",
+            currency: "USDC",
+            regionId,
+        });
+    }
+    /**
+     * Forward USDC to mint GCTL (existing functionality, keeping for compatibility)
+     */
+    async function mintGCTL(amount, userAddress) {
+        assertSigner(signer);
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: "MintGCTL",
+            currency: "USDC",
+        });
+    }
+    /**
+     * Forward tokens to buy a solar farm
+     */
+    async function buySolarFarm(amount, userAddress, farmId, currency = "USDC") {
+        assertSigner(signer);
+        return forwardTokens({
+            amount,
+            userAddress,
+            type: "BuySolarFarm",
+            currency,
+            farmId,
+        });
+    }
+    /**
+     * Estimate gas for forwarding with type-specific handling
+     * @param params Forward parameters
+     * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
+     */
+    async function estimateGasForForward(params, ethPriceInUSD) {
+        assertSigner(signer);
+        try {
+            const forwarderContract = getForwarderContract();
+            if (!forwarderContract)
+                throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+            const { amount, currency = "USDC" } = params;
+            // Construct the appropriate message for this forward type
+            const message = constructForwardMessage(params);
+            // Get token address
+            let tokenAddress;
+            switch (currency) {
+                case "USDC":
+                    tokenAddress = ADDRESSES.USDC;
+                    break;
+                case "USDG":
+                    tokenAddress = ADDRESSES.USDG;
+                    break;
+                case "GLW":
+                    tokenAddress = ADDRESSES.GLW;
+                    break;
+                default:
+                    throw new Error(`Unsupported currency for gas estimation: ${currency}`);
+            }
+            const gasPrice = await signer.getGasPrice();
+            const estimatedGas = await forwarderContract.estimateGas.forward(tokenAddress, ADDRESSES.FOUNDATION_WALLET, amount, message);
+            const estimatedCost = estimatedGas.mul(gasPrice);
+            if (ethPriceInUSD) {
+                const estimatedCostInEth = ethers.utils.formatEther(estimatedCost);
+                const estimatedCostInUSD = (parseFloat(estimatedCostInEth) * ethPriceInUSD).toFixed(2);
+                return estimatedCostInUSD;
+            }
+            else {
+                throw new Error("Could not fetch the ETH price to calculate cost in USD.");
+            }
+        }
+        catch (error) {
+            throw new Error(parseEthersError(error));
+        }
+    }
+    /**
+     * Mint test USDC (only works on testnets with mintable USDC contracts)
+     * @param amount Amount of USDC to mint (BigNumber, 6 decimals)
+     * @param recipient Address to mint USDC to
+     */
+    async function mintTestUSDC(amount, recipient) {
+        assertSigner(signer);
+        if (CHAIN_ID !== 11155111) {
+            throw new Error("Minting test USDC is only supported on Sepolia");
+        }
+        try {
+            const usdcContract = getTokenContract("USDC"); // Use getTokenContract for consistency
+            if (!usdcContract)
+                throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+            setIsProcessing(true);
+            // Try to call mint function (common for test tokens)
+            const tx = await usdcContract.mint(recipient, amount);
+            await tx.wait();
+            return tx.hash;
+        }
+        catch (error) {
+            // If mint function doesn't exist or fails, provide helpful error
+            const errorMessage = parseEthersError(error);
+            if (errorMessage.includes("mint")) {
+                throw new Error("This USDC contract doesn't support minting");
+            }
+            throw new Error(errorMessage);
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    return {
+        // New methods for different forward types
+        forwardTokens,
+        payProtocolFeeAndMintGCTLAndStake,
+        payProtocolFee,
+        mintGCTLAndStake,
+        mintGCTL,
+        buySolarFarm,
+        // Token operations
+        approveToken,
+        checkTokenAllowance,
+        checkTokenBalance,
+        // Utility methods
+        estimateGasForForward,
+        mintTestUSDC,
+        constructForwardMessage,
+        // State
+        get isProcessing() {
+            return isProcessing;
+        },
+        addresses: ADDRESSES,
+        // Signer availability
+        isSignerAvailable: !!signer,
+    };
+}
+
+export { GENESIS_TIMESTAMP, createWeeklyReport, createWeeklyReportLegacy, useForwarder };
 //# sourceMappingURL=index.js.map