@glowlabs-org/utils 0.2.0 → 0.2.2

package/dist/esm/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/esm/constants/addresses.d.ts

@@ -1,3 +1,4 @@
 type ContractKeys = "USDC" | "FORWARDER" | "FOUNDATION_WALLET" | "GLW" | "USDG";
 export declare const getAddresses: (CHAIN_ID: number) => Record<ContractKeys, `0x${string}`>;
+export declare const DECIMALS_BY_TOKEN: Record<string, number>;
 export {};

package/dist/esm/index.js

@@ -13,6 +13,8 @@ import { parseUnits, formatUnits } from 'viem';
 import { MerkleTree } from 'merkletreejs';
 import { ethers, BigNumber } from 'ethers';
 import Decimal from 'decimal.js';
+import { H as HUB_URL, U as USDG_WEIGHT_DECIMAL_PRECISION, G as GLOW_WEIGHT_DECIMAL_PRECISION, M as MAX_WEIGHT } from './use-forwarder-DD_5ZFZg.js';
+export { u as useForwarder } from './use-forwarder-DD_5ZFZg.js';
 
 const GENESIS_TIMESTAMP = 1700352000;
 
@@ -18626,8 +18628,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(parseUnits(customToFixed(percentage, numberOfDecimals), numberOfDecimals));
@@ -18691,19 +18691,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.utils.solidityKeccak256(leafTypes, [
@@ -19165,557 +19152,5 @@ 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.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 };
+export { GENESIS_TIMESTAMP, createWeeklyReport, createWeeklyReportLegacy };
 //# sourceMappingURL=index.js.map