@glowlabs-org/utils 0.2.154 → 0.2.156

package/dist/cjs/{farms-router-DwbBMkUd.js → farms-router-DekpTBQj.js}

@@ -1564,7 +1564,7 @@ exports.OffchainFractionsError = void 0;
     OffchainFractionsError["INSUFFICIENT_ALLOWANCE"] = "Insufficient allowance";
 })(exports.OffchainFractionsError || (exports.OffchainFractionsError = {}));
 // Type-guard style helper to ensure a wallet client exists throughout the rest of the function.
-function assertWalletClient(maybeWalletClient) {
+function assertWalletClient$1(maybeWalletClient) {
     if (!maybeWalletClient) {
         throw new Error(exports.OffchainFractionsError.SIGNER_NOT_AVAILABLE);
     }
@@ -1632,7 +1632,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
      * @param amount Amount to approve (BigNumber)
      */
     async function approveToken(tokenAddress, amount) {
-        assertWalletClient(walletClient);
+        assertWalletClient$1(walletClient);
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
@@ -1659,7 +1659,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
      * @param params Parameters for creating the fraction
      */
     async function createFraction(params) {
-        assertWalletClient(walletClient);
+        assertWalletClient$1(walletClient);
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
@@ -1761,7 +1761,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
      * @param params Parameters for buying fractions
      */
     async function buyFractions(params) {
-        assertWalletClient(walletClient);
+        assertWalletClient$1(walletClient);
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
@@ -1891,7 +1891,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
      * @param id The unique identifier of the fraction sale
      */
     async function claimRefund(user, creator, id) {
-        assertWalletClient(walletClient);
+        assertWalletClient$1(walletClient);
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
@@ -1995,7 +1995,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
      * @param id The unique identifier of the fraction sale to close
      */
     async function closeFraction(creator, id) {
-        assertWalletClient(walletClient);
+        assertWalletClient$1(walletClient);
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
@@ -2176,7 +2176,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
      * @param useCounterfactualAddress Whether to use counterfactual address for refunds
      */
     async function setRefundDetails(creator, id, refundTo, useCounterfactualAddress) {
-        assertWalletClient(walletClient);
+        assertWalletClient$1(walletClient);
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
@@ -2264,7 +2264,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
      * @param isApproved Whether to approve or revoke the operator
      */
     async function setRefundOperatorStatus(refundOperator, isApproved) {
-        assertWalletClient(walletClient);
+        assertWalletClient$1(walletClient);
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
@@ -2449,7 +2449,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
      * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
      */
     async function estimateGasForCreateFraction(params, ethPriceInUSD) {
-        assertWalletClient(walletClient);
+        assertWalletClient$1(walletClient);
         assertPublicClient(publicClient);
         try {
             const { id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise, closer, } = params;
@@ -2494,7 +2494,7 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
      * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
      */
     async function estimateGasForBuyFractions(params, ethPriceInUSD) {
-        assertWalletClient(walletClient);
+        assertWalletClient$1(walletClient);
         assertPublicClient(publicClient);
         try {
             const { creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund, } = params;
@@ -2570,6 +2570,680 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
     };
 }
 
+const REWARDS_KERNEL_ABI = [
+    {
+        inputs: [
+            { internalType: "address", name: "_foundationMultisig", type: "address" },
+            { internalType: "address", name: "_rejectionMultisig", type: "address" },
+            {
+                internalType: "contract CounterfactualHolderFactory",
+                name: "f",
+                type: "address",
+            },
+            { internalType: "uint256", name: "_finality", type: "uint256" },
+        ],
+        stateMutability: "payable",
+        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: "AlreadyClaimedNonce", type: "error" },
+    { inputs: [], name: "AlreadyFinalized", type: "error" },
+    { inputs: [], name: "AlreadyRejected", type: "error" },
+    { inputs: [], name: "CannotClaimFromRejectedNonce", type: "error" },
+    { inputs: [], name: "CannotPostZeroRoot", type: "error" },
+    { inputs: [], name: "DuplicateToken", type: "error" },
+    { inputs: [], name: "FailedInnerCall", type: "error" },
+    { inputs: [], name: "InvalidMerkleProof", type: "error" },
+    { inputs: [], name: "LengthsDontMatch", type: "error" },
+    { inputs: [], name: "MaxClaimedExceeded", type: "error" },
+    { inputs: [], name: "NonexistentDataAtNonce", type: "error" },
+    { inputs: [], name: "NotFoundationMultisig", type: "error" },
+    { inputs: [], name: "NotRejectionMultisig", type: "error" },
+    { inputs: [], name: "NotYetFinalized", type: "error" },
+    { inputs: [], name: "ReentrancyGuardReentrantCall", type: "error" },
+    {
+        inputs: [{ internalType: "address", name: "token", type: "address" }],
+        name: "SafeERC20FailedOperation",
+        type: "error",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "uint256",
+                name: "nonce",
+                type: "uint256",
+            },
+        ],
+        name: "NonceRejected",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "address", name: "user", type: "address" },
+            { indexed: true, internalType: "address", name: "to", type: "address" },
+            {
+                indexed: true,
+                internalType: "uint256",
+                name: "nonce",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
+            {
+                components: [
+                    { internalType: "address", name: "token", type: "address" },
+                    { internalType: "uint256", name: "amount", type: "uint256" },
+                ],
+                indexed: false,
+                internalType: "struct FoundationRewardKernel.TokenAndAmount[]",
+                name: "taa",
+                type: "tuple[]",
+            },
+            {
+                indexed: false,
+                internalType: "bool[]",
+                name: "isGuarded",
+                type: "bool[]",
+            },
+        ],
+        name: "RewardClaimed",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "uint256",
+                name: "nonce",
+                type: "uint256",
+            },
+            { indexed: true, internalType: "bytes32", name: "root", type: "bytes32" },
+            {
+                components: [
+                    { internalType: "address", name: "token", type: "address" },
+                    { internalType: "uint256", name: "amount", type: "uint256" },
+                ],
+                indexed: false,
+                internalType: "struct FoundationRewardKernel.TokenAndAmount[]",
+                name: "taa",
+                type: "tuple[]",
+            },
+        ],
+        name: "RootPosted",
+        type: "event",
+    },
+    {
+        inputs: [],
+        name: "$nextPostNonce",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "CFH_FACTORY",
+        outputs: [
+            {
+                internalType: "contract CounterfactualHolderFactory",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "FINALITY",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "FOUNDATION_MULTISIG",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "REJECTION_MULTISIG",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "uint256", name: "nonce", type: "uint256" },
+            { internalType: "bytes32[]", name: "proof", type: "bytes32[]" },
+            {
+                components: [
+                    { internalType: "address", name: "token", type: "address" },
+                    { internalType: "uint256", name: "amount", type: "uint256" },
+                ],
+                internalType: "struct FoundationRewardKernel.TokenAndAmount[]",
+                name: "taa",
+                type: "tuple[]",
+            },
+            { internalType: "address", name: "from", type: "address" },
+            { internalType: "address", name: "to", type: "address" },
+            { internalType: "bool[]", name: "isGuardedToken", type: "bool[]" },
+            { internalType: "bool[]", name: "toCounterfactual", type: "bool[]" },
+        ],
+        name: "claimPayout",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "uint256", name: "nonce", type: "uint256" },
+            { internalType: "address", name: "token", type: "address" },
+        ],
+        name: "getAmountClaimed",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "uint256", name: "nonce", type: "uint256" },
+            { internalType: "address", name: "token", type: "address" },
+        ],
+        name: "getMaxReward",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "uint256", name: "nonce", type: "uint256" }],
+        name: "getRewardMeta",
+        outputs: [
+            { internalType: "bytes32", name: "merkleRoot", type: "bytes32" },
+            { internalType: "uint48", name: "pushTimestamp", type: "uint48" },
+            { internalType: "bool", name: "rejected", type: "bool" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "user", type: "address" },
+            { internalType: "uint256", name: "nonce", type: "uint256" },
+        ],
+        name: "isClaimed",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "uint256", name: "nonce", type: "uint256" }],
+        name: "isFinalized",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "bytes[]", name: "data", type: "bytes[]" }],
+        name: "multicall",
+        outputs: [{ internalType: "bytes[]", name: "results", type: "bytes[]" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "bytes32", name: "root", type: "bytes32" },
+            {
+                components: [
+                    { internalType: "address", name: "token", type: "address" },
+                    { internalType: "uint256", name: "amount", type: "uint256" },
+                ],
+                internalType: "struct FoundationRewardKernel.TokenAndAmount[]",
+                name: "taa",
+                type: "tuple[]",
+            },
+        ],
+        name: "postPayoutRoot",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "uint256", name: "nonce", type: "uint256" }],
+        name: "rejectNonce",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+];
+
+exports.RewardsKernelError = void 0;
+(function (RewardsKernelError) {
+    RewardsKernelError["CONTRACT_NOT_AVAILABLE"] = "Contract not available";
+    RewardsKernelError["SIGNER_NOT_AVAILABLE"] = "Signer not available";
+    RewardsKernelError["UNKNOWN_ERROR"] = "Unknown error";
+    RewardsKernelError["INVALID_PARAMETERS"] = "Invalid parameters";
+    RewardsKernelError["ALREADY_CLAIMED"] = "Already claimed from this nonce";
+    RewardsKernelError["NOT_FINALIZED"] = "Nonce not yet finalized";
+    RewardsKernelError["NONCE_REJECTED"] = "Cannot claim from rejected nonce";
+})(exports.RewardsKernelError || (exports.RewardsKernelError = {}));
+// Type-guard style helper to ensure a wallet client exists
+function assertWalletClient(maybeWalletClient) {
+    if (!maybeWalletClient) {
+        throw new Error(exports.RewardsKernelError.SIGNER_NOT_AVAILABLE);
+    }
+    if (!maybeWalletClient.account) {
+        throw new Error("Wallet client must have an account");
+    }
+}
+function useRewardsKernel(walletClient, publicClient, 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;
+    };
+    // Helper to assert public client is available
+    function assertPublicClient(maybePublicClient) {
+        if (!maybePublicClient) {
+            throw new Error("Public client not available");
+        }
+    }
+    /**
+     * Claim payout from a finalized nonce
+     * @param params Parameters for claiming the payout
+     */
+    async function claimPayout(params) {
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
+        try {
+            setIsProcessing(true);
+            sentryAddBreadcrumb({
+                category: "rewards-kernel",
+                message: "claimPayout.start",
+                level: "info",
+                data: {
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.REWARDS_KERNEL,
+                    nonce: params.nonce.toString(),
+                    to: params.to,
+                    from: params.from,
+                    tokensCount: params.tokensAndAmounts.length,
+                },
+            });
+            const { nonce, proof, tokensAndAmounts, from, to, isGuardedToken, toCounterfactual, } = params;
+            // Validate parameters
+            if (!proof || proof.length === 0) {
+                throw new Error("Merkle proof is required");
+            }
+            if (!tokensAndAmounts || tokensAndAmounts.length === 0) {
+                throw new Error("Tokens and amounts are required");
+            }
+            if (isGuardedToken.length !== tokensAndAmounts.length) {
+                throw new Error("isGuardedToken array length must match tokensAndAmounts");
+            }
+            if (toCounterfactual.length !== tokensAndAmounts.length) {
+                throw new Error("toCounterfactual array length must match tokensAndAmounts");
+            }
+            if (!from || !to) {
+                throw new Error(exports.RewardsKernelError.INVALID_PARAMETERS);
+            }
+            // Check if already claimed
+            const owner = walletClient.account?.address;
+            if (!owner) {
+                throw new Error("No account found in wallet client");
+            }
+            const alreadyClaimed = await isClaimed(owner, nonce);
+            if (alreadyClaimed) {
+                throw new Error(exports.RewardsKernelError.ALREADY_CLAIMED);
+            }
+            // Check if finalized
+            const finalized = await isFinalized(nonce);
+            if (!finalized) {
+                throw new Error(exports.RewardsKernelError.NOT_FINALIZED);
+            }
+            // Run a simulation first to surface any revert reason
+            try {
+                await publicClient.simulateContract({
+                    address: ADDRESSES.REWARDS_KERNEL,
+                    abi: REWARDS_KERNEL_ABI,
+                    functionName: "claimPayout",
+                    args: [
+                        nonce,
+                        proof,
+                        tokensAndAmounts,
+                        from,
+                        to,
+                        isGuardedToken,
+                        toCounterfactual,
+                    ],
+                    account: walletClient.account,
+                });
+            }
+            catch (simulationError) {
+                sentryCaptureException(simulationError, {
+                    action: "claimPayout.simulate",
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.REWARDS_KERNEL,
+                    nonce: nonce.toString(),
+                });
+                throw new Error(parseViemError(simulationError));
+            }
+            // Execute the transaction
+            const hash = await walletClient.writeContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "claimPayout",
+                args: [
+                    nonce,
+                    proof,
+                    tokensAndAmounts,
+                    from,
+                    to,
+                    isGuardedToken,
+                    toCounterfactual,
+                ],
+                chain: walletClient.chain,
+                account: walletClient.account,
+            });
+            await waitForViemTransactionWithRetry(publicClient, hash);
+            return hash;
+        }
+        catch (error) {
+            sentryCaptureException(error, {
+                action: "claimPayout",
+                chainId: walletClient?.chain?.id,
+                contract: ADDRESSES.REWARDS_KERNEL,
+                nonce: params.nonce.toString(),
+                from: params.from,
+                to: params.to,
+            });
+            throw new Error(parseViemError(error));
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }
+    /**
+     * Get reward metadata for a specific nonce
+     * @param nonce The nonce to query
+     */
+    async function getRewardMeta(nonce) {
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "getRewardMeta",
+                args: [nonce],
+            }));
+            return {
+                merkleRoot: result[0],
+                pushTimestamp: Number(result[1]),
+                rejected: result[2],
+            };
+        }
+        catch (error) {
+            throw new Error(parseViemError(error));
+        }
+    }
+    /**
+     * Get the maximum claimable amount for a token at a specific nonce
+     * @param nonce The nonce to query
+     * @param token The token address
+     */
+    async function getMaxReward(nonce, token) {
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "getMaxReward",
+                args: [nonce, token],
+            }));
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseViemError(error));
+        }
+    }
+    /**
+     * Get the amount already claimed for a token at a specific nonce
+     * @param nonce The nonce to query
+     * @param token The token address
+     */
+    async function getAmountClaimed(nonce, token) {
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "getAmountClaimed",
+                args: [nonce, token],
+            }));
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseViemError(error));
+        }
+    }
+    /**
+     * Check if a nonce is finalized and claimable
+     * @param nonce The nonce to check
+     */
+    async function isFinalized(nonce) {
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "isFinalized",
+                args: [nonce],
+            }));
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseViemError(error));
+        }
+    }
+    /**
+     * Check if a user has already claimed from a specific nonce
+     * @param user The user address
+     * @param nonce The nonce to check
+     */
+    async function isClaimed(user, nonce) {
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "isClaimed",
+                args: [user, nonce],
+            }));
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseViemError(error));
+        }
+    }
+    /**
+     * Get the next nonce that will be used for posting
+     */
+    async function getNextPostNonce() {
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "$nextPostNonce",
+                args: [],
+            }));
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseViemError(error));
+        }
+    }
+    /**
+     * Get the finality period in seconds
+     */
+    async function getFinality() {
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "FINALITY",
+                args: [],
+            }));
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseViemError(error));
+        }
+    }
+    /**
+     * Get the foundation multisig address
+     */
+    async function getFoundationMultisig() {
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "FOUNDATION_MULTISIG",
+                args: [],
+            }));
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseViemError(error));
+        }
+    }
+    /**
+     * Get the rejection multisig address
+     */
+    async function getRejectionMultisig() {
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "REJECTION_MULTISIG",
+                args: [],
+            }));
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseViemError(error));
+        }
+    }
+    /**
+     * Get the counterfactual holder factory address
+     */
+    async function getCFHFactory() {
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "CFH_FACTORY",
+                args: [],
+            }));
+            return result;
+        }
+        catch (error) {
+            throw new Error(parseViemError(error));
+        }
+    }
+    /**
+     * Estimate gas for claiming a payout
+     * @param params Parameters for claiming the payout
+     * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
+     */
+    async function estimateGasForClaimPayout(params, ethPriceInUSD) {
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
+        try {
+            const { nonce, proof, tokensAndAmounts, from, to, isGuardedToken, toCounterfactual, } = params;
+            const gasPrice = await publicClient.getGasPrice();
+            if (!gasPrice) {
+                throw new Error("Could not fetch gas price to estimate cost.");
+            }
+            const estimatedGas = await publicClient.estimateContractGas({
+                address: ADDRESSES.REWARDS_KERNEL,
+                abi: REWARDS_KERNEL_ABI,
+                functionName: "claimPayout",
+                args: [
+                    nonce,
+                    proof,
+                    tokensAndAmounts,
+                    from,
+                    to,
+                    isGuardedToken,
+                    toCounterfactual,
+                ],
+                account: walletClient.account,
+            });
+            const estimatedCost = estimatedGas * gasPrice;
+            if (ethPriceInUSD) {
+                const estimatedCostInEth = viem.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(parseViemError(error));
+        }
+    }
+    return {
+        // Core contract functions
+        claimPayout,
+        // View functions
+        getRewardMeta,
+        getMaxReward,
+        getAmountClaimed,
+        isFinalized,
+        isClaimed,
+        getNextPostNonce,
+        getFinality,
+        getFoundationMultisig,
+        getRejectionMultisig,
+        getCFHFactory,
+        // Gas estimation
+        estimateGasForClaimPayout,
+        // State
+        get isProcessing() {
+            return isProcessing;
+        },
+        addresses: ADDRESSES,
+        // Wallet client availability
+        isSignerAvailable: !!walletClient,
+    };
+}
+
 // --------------------------------------------------------------------------
 /**
  * Extract a useful error message from an unknown error value.
@@ -3830,6 +4504,25 @@ function RegionRouter(baseUrl) {
             throw new Error(parseApiError$3(error));
         }
     };
+    const fetchRegionWeeklyRewards = async (regionId, query) => {
+        try {
+            const params = new URLSearchParams();
+            if (query?.startWeek !== undefined)
+                params.set("startWeek", query.startWeek.toString());
+            if (query?.endWeek !== undefined)
+                params.set("endWeek", query.endWeek.toString());
+            if (query?.paymentCurrency)
+                params.set("paymentCurrency", query.paymentCurrency);
+            if (query?.limit !== undefined)
+                params.set("limit", query.limit.toString());
+            const queryString = params.toString();
+            const path = `/regions/weekly-rewards/${regionId}${queryString ? `?${queryString}` : ""}`;
+            return await request(path);
+        }
+        catch (error) {
+            throw new Error(parseApiError$3(error));
+        }
+    };
     const applyInstallerCertification = async (payload) => {
         try {
             return await request(`/regions/installers/apply`, {
@@ -3891,6 +4584,7 @@ function RegionRouter(baseUrl) {
         fetchRegionSolarFarms,
         fetchActiveSummary,
         fetchRecentActivity,
+        fetchRegionWeeklyRewards,
         getRegionByCode,
         applyInstallerCertification,
         // Cached data & flags
@@ -4108,11 +4802,31 @@ function WalletsRouter(baseUrl) {
             throw new Error(parseApiError$1(error));
         }
     };
+    const fetchWalletWeeklyRewards = async (wallet, query) => {
+        try {
+            const params = new URLSearchParams();
+            if (query?.startWeek !== undefined)
+                params.set("startWeek", query.startWeek.toString());
+            if (query?.endWeek !== undefined)
+                params.set("endWeek", query.endWeek.toString());
+            if (query?.paymentCurrency)
+                params.set("paymentCurrency", query.paymentCurrency);
+            if (query?.limit !== undefined)
+                params.set("limit", query.limit.toString());
+            const queryString = params.toString();
+            const path = `/wallets/address/${encodeURIComponent(wallet)}/weekly-rewards${queryString ? `?${queryString}` : ""}`;
+            return await request(path);
+        }
+        catch (error) {
+            throw new Error(parseApiError$1(error));
+        }
+    };
     return {
         fetchAllWallets,
         fetchWalletByAddress,
         fetchWalletMintedEvents,
         fetchWalletStakeEvents,
+        fetchWalletWeeklyRewards,
     };
 }
 
@@ -4176,6 +4890,28 @@ function FarmsRouter(baseUrl) {
             throw new Error(parseApiError(error));
         }
     };
+    const fetchFarmWeeklyRewards = async (farmId, query) => {
+        try {
+            if (!farmId) {
+                throw new Error("Farm ID is required");
+            }
+            const params = new URLSearchParams();
+            if (query?.startWeek !== undefined)
+                params.set("startWeek", query.startWeek.toString());
+            if (query?.endWeek !== undefined)
+                params.set("endWeek", query.endWeek.toString());
+            if (query?.paymentCurrency)
+                params.set("paymentCurrency", query.paymentCurrency);
+            if (query?.limit !== undefined)
+                params.set("limit", query.limit.toString());
+            const queryString = params.toString();
+            const path = `/farms/${encodeURIComponent(farmId)}/weekly-rewards${queryString ? `?${queryString}` : ""}`;
+            return await request(path);
+        }
+        catch (error) {
+            throw new Error(parseApiError(error));
+        }
+    };
     const estimateRewardScore = async (params) => {
         try {
             sentryAddBreadcrumb({
@@ -4266,6 +5002,7 @@ function FarmsRouter(baseUrl) {
         fetchFarmRewardSplits,
         fetchSponsoredFarms,
         fetchWalletFarmsWithRewards,
+        fetchFarmWeeklyRewards,
         estimateRewardScore,
         estimateRewardScoresBatch,
         calculateMiningScoresBatch,
@@ -4284,6 +5021,7 @@ exports.MAX_WEIGHT = MAX_WEIGHT;
 exports.OFFCHAIN_FRACTIONS_ABI = OFFCHAIN_FRACTIONS_ABI;
 exports.OFF_CHAIN_PAYMENT_CURRENCIES = OFF_CHAIN_PAYMENT_CURRENCIES;
 exports.PAYMENT_CURRENCIES = PAYMENT_CURRENCIES;
+exports.REWARDS_KERNEL_ABI = REWARDS_KERNEL_ABI;
 exports.RegionRouter = RegionRouter;
 exports.TRANSFER_TYPES = TRANSFER_TYPES;
 exports.USDG_WEIGHT_DECIMAL_PRECISION = USDG_WEIGHT_DECIMAL_PRECISION;
@@ -4298,6 +5036,7 @@ exports.regionMetadata = regionMetadata;
 exports.usStates = usStates;
 exports.useForwarder = useForwarder;
 exports.useOffchainFractions = useOffchainFractions;
+exports.useRewardsKernel = useRewardsKernel;
 exports.waitForEthersTransactionWithRetry = waitForEthersTransactionWithRetry;
 exports.waitForViemTransactionWithRetry = waitForViemTransactionWithRetry;
-//# sourceMappingURL=farms-router-DwbBMkUd.js.map
+//# sourceMappingURL=farms-router-DekpTBQj.js.map