@glowlabs-org/utils 0.2.1 → 0.2.2

package/dist/cjs/index.js

@@ -15,6 +15,7 @@ var viem = require('viem');
 var merkletreejs = require('merkletreejs');
 var ethers = require('ethers');
 var Decimal = require('decimal.js');
+var useForwarder = require('./use-forwarder-CVlJS4UY.js');
 
 const GENESIS_TIMESTAMP = 1700352000;
 
@@ -18628,8 +18629,6 @@ function customToFixed(num, precision) {
     return fixed;
 }
 
-const HUB_URL = "https://glow.org";
-
 function multiplyBigIntByDecimalPercentage(bigInt, numberOfDecimals, percentage) {
     const DENOMINATOR = BigInt(10 ** numberOfDecimals);
     const percentageAsBigNum = BigInt(viem.parseUnits(customToFixed(percentage, numberOfDecimals), numberOfDecimals));
@@ -18693,19 +18692,6 @@ function accumulateLeafWeights(key, value, map) {
 // Numeric string regex: matches valid numbers (digits, optional single dot, digits after dot)
 const NUMERIC_REGEX = /^(?:\d+\.?\d*|\.\d+)$/;
 
-/**
- * @dev This is actually not as intuitive as it seems.
- * Glow actually has 18 decimals, but glow weight is based on the amount of protocol fees (USDC) that the farm paid
- * Therefore, the weight is based on the amount of USDC that was paid, which has 8 decimals
- */
-const GLOW_WEIGHT_DECIMAL_PRECISION = 8;
-/**
- * @dev This is actually not as intuitive as it seems.
- * USDG weight is based on the amount of carbon credits produced, but the max value of a weight is ((2*64)-1) / 5 so we need to choose sensible precision to make sure that number never overflows
- */
-const USDG_WEIGHT_DECIMAL_PRECISION = 8;
-const MAX_WEIGHT = (BigInt(2) ** BigInt(64) - BigInt(1)) / BigInt(5);
-
 const leafTypes = ["address", "uint256", "uint256"];
 function hashLeaf({ address, glowWeight, usdcWeight, }) {
     const hash = ethers.ethers.utils.solidityKeccak256(leafTypes, [
@@ -18723,14 +18709,14 @@ async function createWeeklyReportLegacy(args) {
             const existingValue = map.get(key);
             existingValue.glowWeight += value.glowWeight;
             existingValue.usdgWeight += value.usdgWeight;
-            if (existingValue.glowWeight > MAX_WEIGHT ||
-                existingValue.usdgWeight > MAX_WEIGHT) {
+            if (existingValue.glowWeight > useForwarder.MAX_WEIGHT ||
+                existingValue.usdgWeight > useForwarder.MAX_WEIGHT) {
                 throw new Error(`Accumulated weight overflow on wallet ${key}`);
             }
             map.set(key, existingValue);
         }
         else {
-            if (value.glowWeight > MAX_WEIGHT || value.usdgWeight > MAX_WEIGHT) {
+            if (value.glowWeight > useForwarder.MAX_WEIGHT || value.usdgWeight > useForwarder.MAX_WEIGHT) {
                 throw new Error(`Initial weight overflow on wallet ${key}`);
             }
             map.set(key, value);
@@ -18759,10 +18745,10 @@ async function createWeeklyReportLegacy(args) {
         if (Math.abs(sumOfRewardSplitsUSDGWeight - 1) > percentTolerance)
             throw new Error(`USDG weight splits do not add up to 1 for farm ${farm.shortId}`);
         for (const rewardSplit of farm.rewardSplits) {
-            const glowBigInt = BigInt(viem.parseUnits(customToFixed(farm.weeklyPayment, GLOW_WEIGHT_DECIMAL_PRECISION), GLOW_WEIGHT_DECIMAL_PRECISION));
-            const usdgBigInt = BigInt(viem.parseUnits(customToFixed(farm.carbonCreditsProduced, USDG_WEIGHT_DECIMAL_PRECISION), USDG_WEIGHT_DECIMAL_PRECISION));
-            const glowWeight = multiplyBigIntByDecimalPercentage(glowBigInt, GLOW_WEIGHT_DECIMAL_PRECISION, rewardSplit.glowSplitPercent);
-            const usdgWeight = multiplyBigIntByDecimalPercentage(usdgBigInt, USDG_WEIGHT_DECIMAL_PRECISION, rewardSplit.usdgSplitPercent);
+            const glowBigInt = BigInt(viem.parseUnits(customToFixed(farm.weeklyPayment, useForwarder.GLOW_WEIGHT_DECIMAL_PRECISION), useForwarder.GLOW_WEIGHT_DECIMAL_PRECISION));
+            const usdgBigInt = BigInt(viem.parseUnits(customToFixed(farm.carbonCreditsProduced, useForwarder.USDG_WEIGHT_DECIMAL_PRECISION), useForwarder.USDG_WEIGHT_DECIMAL_PRECISION));
+            const glowWeight = multiplyBigIntByDecimalPercentage(glowBigInt, useForwarder.GLOW_WEIGHT_DECIMAL_PRECISION, rewardSplit.glowSplitPercent);
+            const usdgWeight = multiplyBigIntByDecimalPercentage(usdgBigInt, useForwarder.USDG_WEIGHT_DECIMAL_PRECISION, rewardSplit.usdgSplitPercent);
             const value = {
                 wallet: rewardSplit.walletAddress,
                 glowWeight,
@@ -18807,10 +18793,10 @@ async function createWeeklyReportLegacy(args) {
     const root = tree.getHexRoot();
     const totalGlowWeightFinalizedLeavesSum = finalLeaves.reduce((acc, { glowWeight }) => acc.add(glowWeight), ethers.ethers.BigNumber.from(0));
     const totalGCCWeightFinalizedLeavesSum = finalLeaves.reduce((acc, { usdgWeight }) => acc.add(usdgWeight), ethers.ethers.BigNumber.from(0));
-    if (totalGlowWeightFinalizedLeavesSum.toBigInt() > MAX_WEIGHT) {
+    if (totalGlowWeightFinalizedLeavesSum.toBigInt() > useForwarder.MAX_WEIGHT) {
         throw new Error("Total glow weight is greater than max weight");
     }
-    if (totalGCCWeightFinalizedLeavesSum.toBigInt() > MAX_WEIGHT) {
+    if (totalGCCWeightFinalizedLeavesSum.toBigInt() > useForwarder.MAX_WEIGHT) {
         throw new Error("Total gcc weight is greater than max weight");
     }
     const headlineStats = {
@@ -18818,12 +18804,12 @@ async function createWeeklyReportLegacy(args) {
         totalCreditsProduced: viem.formatUnits(totalCreditsProduced, 18),
         totalCreditsProducedBN: totalCreditsProduced.toString(),
         totalGlowWeightInFinalized: totalGlowWeightFinalizedLeavesSum.toString(),
-        totalGlowWeightHuman: viem.formatUnits(BigInt(totalGlowWeightFinalizedLeavesSum.toString()), GLOW_WEIGHT_DECIMAL_PRECISION).toString(),
+        totalGlowWeightHuman: viem.formatUnits(BigInt(totalGlowWeightFinalizedLeavesSum.toString()), useForwarder.GLOW_WEIGHT_DECIMAL_PRECISION).toString(),
         totalUSDGWeightInFinalized: totalGCCWeightFinalizedLeavesSum.toString(),
-        totalUSDGWeightHuman: viem.formatUnits(BigInt(totalGCCWeightFinalizedLeavesSum.toString()), USDG_WEIGHT_DECIMAL_PRECISION).toString(),
+        totalUSDGWeightHuman: viem.formatUnits(BigInt(totalGCCWeightFinalizedLeavesSum.toString()), useForwarder.USDG_WEIGHT_DECIMAL_PRECISION).toString(),
         root: root,
-        glowWeightDecimals: GLOW_WEIGHT_DECIMAL_PRECISION,
-        usdgWeightDecimals: USDG_WEIGHT_DECIMAL_PRECISION,
+        glowWeightDecimals: useForwarder.GLOW_WEIGHT_DECIMAL_PRECISION,
+        usdgWeightDecimals: useForwarder.USDG_WEIGHT_DECIMAL_PRECISION,
     };
     const farmsWithMerkleProofs = finalLeaves.map((leaf) => {
         const hashedLeaf = hashLeaf({
@@ -18898,7 +18884,7 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
     // Fetch active farms for the week (source of truth) and audits for the week.
     const [apiResponse, auditsRes] = await Promise.all([
         fetchFarmsForWeek(week, gcaUrls, apiUrl),
-        axios.get(`${HUB_URL}/api/audits?omitDocuments=true&weekNumber=${week}`),
+        axios.get(`${useForwarder.HUB_URL}/api/audits?omitDocuments=true&weekNumber=${week}`),
     ]);
     const farms = apiResponse.filteredFarms; // List of farms active this week.
     const audits = auditsRes.data; // Audits potentially containing adjusted credits.
@@ -18947,10 +18933,10 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
         if (splitValue.isZero())
             throw new Error(`Zero adjustedWeeklyCarbonCredit split for active farms in audit ${audit.id}`);
         // Convert the decimal split value to a bigint using the defined precision.
-        const splitBigInt = toBigInt(splitValue, USDG_WEIGHT_DECIMAL_PRECISION);
+        const splitBigInt = toBigInt(splitValue, useForwarder.USDG_WEIGHT_DECIMAL_PRECISION);
         // Dust Check: Ensure that the conversion to bigint didn't truncate the value to zero.
         if (splitBigInt === BigInt(0)) {
-            throw new Error(`Adjusted credit split for audit ${audit.id} resulted in zero BigInt after conversion for precision ${USDG_WEIGHT_DECIMAL_PRECISION}. Original split value: ${splitValue.toString()}. This might indicate dust loss.`);
+            throw new Error(`Adjusted credit split for audit ${audit.id} resulted in zero BigInt after conversion for precision ${useForwarder.USDG_WEIGHT_DECIMAL_PRECISION}. Original split value: ${splitValue.toString()}. This might indicate dust loss.`);
         }
         // Distribute the calculated split value to each active farm associated with this audit.
         for (const sidString of auditActiveFarmSids) {
@@ -18994,7 +18980,7 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
         if (Math.abs(sumUSDG - 1) > percentTolerance)
             throw new Error(`USDG splits ≠1 for farm ${farm.shortId}`);
         // Get the base GLOW payment for the farm, converted to bigint with appropriate precision.
-        const glowBase = viem.parseUnits(customToFixed(farm.weeklyPayment, GLOW_WEIGHT_DECIMAL_PRECISION), GLOW_WEIGHT_DECIMAL_PRECISION);
+        const glowBase = viem.parseUnits(customToFixed(farm.weeklyPayment, useForwarder.GLOW_WEIGHT_DECIMAL_PRECISION), useForwarder.GLOW_WEIGHT_DECIMAL_PRECISION);
         // Retrieve the pre-calculated adjusted credit for this farm. Should always exist due to prior checks.
         const adjustedCreditBigInt = shortIdToAdjustedCredit.get(String(farm.shortId)) ?? BigInt(0);
         // Sanity check (likely redundant due to earlier checks, but safe).
@@ -19003,9 +18989,9 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
         // Process each reward split recipient for this farm.
         for (const split of farm.rewardSplits) {
             // Calculate the GLOW weight for this recipient based on the farm's weekly payment and split percentage.
-            const glowWeight = multiplyBigIntByDecimalPercentage(glowBase, GLOW_WEIGHT_DECIMAL_PRECISION, split.glowSplitPercent);
+            const glowWeight = multiplyBigIntByDecimalPercentage(glowBase, useForwarder.GLOW_WEIGHT_DECIMAL_PRECISION, split.glowSplitPercent);
             // Calculate the USDG weight for this recipient based on the farm's *adjusted* credit and split percentage.
-            const usdgWeight = multiplyBigIntByDecimalPercentage(adjustedCreditBigInt, USDG_WEIGHT_DECIMAL_PRECISION, split.usdgSplitPercent);
+            const usdgWeight = multiplyBigIntByDecimalPercentage(adjustedCreditBigInt, useForwarder.USDG_WEIGHT_DECIMAL_PRECISION, split.usdgSplitPercent);
             // Dust Loss Checks: Ensure non-zero percentages didn't result in zero weight due to precision limits.
             if (split.usdgSplitPercent > 0 &&
                 adjustedCreditBigInt > BigInt(0) &&
@@ -19016,7 +19002,7 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
                 glowWeight === BigInt(0))
                 throw new Error(`Glow dust lost for farm ${farm.shortId} wallet ${split.walletAddress}`);
             // Overflow Check: Ensure individual leaf weights don't exceed the maximum allowed.
-            if (glowWeight > MAX_WEIGHT || usdgWeight > MAX_WEIGHT)
+            if (glowWeight > useForwarder.MAX_WEIGHT || usdgWeight > useForwarder.MAX_WEIGHT)
                 throw new Error(`Leaf weight overflow on wallet ${split.walletAddress}`);
             // Accumulate the calculated weights into the map for the recipient wallet.
             accumulateLeafWeights(split.walletAddress, { wallet: split.walletAddress, glowWeight, usdgWeight }, map);
@@ -19044,9 +19030,9 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
     const totalGlowWeight = finalizedLeaves.reduce((acc, { glowWeight }) => acc.add(glowWeight), ethers.ethers.BigNumber.from(0));
     const totalUSDGWeight = finalizedLeaves.reduce((acc, { usdgWeight }) => acc.add(usdgWeight), ethers.ethers.BigNumber.from(0));
     // Total Weight Overflow Checks: Ensure sums don't exceed maximum.
-    if (totalGlowWeight.toBigInt() > MAX_WEIGHT)
+    if (totalGlowWeight.toBigInt() > useForwarder.MAX_WEIGHT)
         throw new Error("Total glow weight overflow");
-    if (totalUSDGWeight.toBigInt() > MAX_WEIGHT)
+    if (totalUSDGWeight.toBigInt() > useForwarder.MAX_WEIGHT)
         throw new Error("Total USDG weight overflow");
     // Generate Merkle proofs for each leaf and verify them.
     const leavesWithProofs = finalizedLeaves.map((leaf) => {
@@ -19080,10 +19066,10 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
     // Calculate the total expected credits based on the adjusted values used.
     const totalExpectedCredits = farms.reduce((acc, f) => {
         const adj = shortIdToAdjustedCredit.get(String(f.shortId)) ?? BigInt(0);
-        return acc.plus(fromBigInt(adj, USDG_WEIGHT_DECIMAL_PRECISION));
+        return acc.plus(fromBigInt(adj, useForwarder.USDG_WEIGHT_DECIMAL_PRECISION));
     }, new Decimal(0));
     // Convert total USDG weight back to human-readable decimal for deviation check.
-    const totalUSDGWeightHuman = new Decimal(viem.formatUnits(BigInt(totalUSDGWeight.toString()), USDG_WEIGHT_DECIMAL_PRECISION));
+    const totalUSDGWeightHuman = new Decimal(viem.formatUnits(BigInt(totalUSDGWeight.toString()), useForwarder.USDG_WEIGHT_DECIMAL_PRECISION));
     // Check deviation between total adjusted credits used and the final sum of USDG weights.
     if (greaterThanMaxDeviation(totalExpectedCredits.toNumber(), totalUSDGWeightHuman.toNumber(), 0.001 // 0.1% tolerance
     )) {
@@ -19094,7 +19080,7 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
         throw new Error("totalExpectedCredits vs USDG weight deviation >0.1% ");
     }
     // Convert total Glow weight back to human-readable decimal.
-    const totalGlowWeightHuman = new Decimal(viem.formatUnits(BigInt(totalGlowWeight.toString()), GLOW_WEIGHT_DECIMAL_PRECISION));
+    const totalGlowWeightHuman = new Decimal(viem.formatUnits(BigInt(totalGlowWeight.toString()), useForwarder.GLOW_WEIGHT_DECIMAL_PRECISION));
     // Sum the original weekly protocol fee payments from farm data.
     const totalProtocolFeePayments = farms.reduce((acc, f) => acc + f.weeklyPayment, 0);
     // Check deviation between total glow weight and total protocol fees paid.
@@ -19117,18 +19103,18 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
         totalUSDGWeightInFinalized: totalUSDGWeight.toString(),
         totalUSDGWeightHuman: totalUSDGWeightHuman.toString(),
         root: merkleRoot,
-        glowWeightDecimals: GLOW_WEIGHT_DECIMAL_PRECISION,
-        usdgWeightDecimals: USDG_WEIGHT_DECIMAL_PRECISION,
+        glowWeightDecimals: useForwarder.GLOW_WEIGHT_DECIMAL_PRECISION,
+        usdgWeightDecimals: useForwarder.USDG_WEIGHT_DECIMAL_PRECISION,
     };
     // List of shortIds and their final adjusted credit value (human-readable).
     const shortIdAdjustedList = Array.from(shortIdToAdjustedCredit.entries()).map(([shortId, creditBigInt]) => ({
         shortId,
-        adjustedCredit: fromBigInt(creditBigInt, USDG_WEIGHT_DECIMAL_PRECISION).toString(),
+        adjustedCredit: fromBigInt(creditBigInt, useForwarder.USDG_WEIGHT_DECIMAL_PRECISION).toString(),
     }));
     // Detailed comparison between originally reported credits and adjusted credits for each farm.
     const creditsDeviationList = farms.map((farm) => {
         const adj = shortIdToAdjustedCredit.get(String(farm.shortId)) ?? BigInt(0);
-        const adjusted = fromBigInt(adj, USDG_WEIGHT_DECIMAL_PRECISION);
+        const adjusted = fromBigInt(adj, useForwarder.USDG_WEIGHT_DECIMAL_PRECISION);
         const produced = new Decimal(farm.carbonCreditsProduced);
         let deviation;
         let absDeviation;
@@ -19167,560 +19153,8 @@ async function createWeeklyReport({ week, gcaUrls, apiUrl, }) {
     };
 }
 
-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.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.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.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.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,
-    };
-}
-
+exports.useForwarder = useForwarder.useForwarder;
 exports.GENESIS_TIMESTAMP = GENESIS_TIMESTAMP;
 exports.createWeeklyReport = createWeeklyReport;
 exports.createWeeklyReportLegacy = createWeeklyReportLegacy;
-exports.useForwarder = useForwarder;
 //# sourceMappingURL=index.js.map