@glowlabs-org/utils 0.2.142 → 0.2.145

package/dist/cjs/{farms-router-CCva--xp.js → farms-router-C8V_F0vY.js}

@@ -508,6 +508,70 @@ async function waitForEthersTransactionWithRetry(signer, txHash, options = {}) {
     throw new Error(`Transaction failed after ${maxRetries} attempts: ${parseEthersError(lastError)}`);
 }
 
+let configuredClient = null;
+let isEnabled = true;
+let defaultExtra = {};
+function getSentry() {
+    const client = configuredClient ??
+        globalThis?.Sentry;
+    if (!client || typeof client.captureException !== "function")
+        return null;
+    return client;
+}
+function configureSentry(config) {
+    if (config.enabled !== undefined)
+        isEnabled = !!config.enabled;
+    if (config.client !== undefined)
+        configuredClient = config.client;
+    if (config.defaultContext)
+        defaultExtra = { ...config.defaultContext };
+}
+function shouldSkipSentry(error) {
+    try {
+        const possible = error;
+        const code = possible?.code || possible?.cause?.code;
+        const name = possible?.name || possible?.cause?.name;
+        const message = String(possible?.message || possible?.cause?.message || "");
+        // User rejected wallet request (ethers/viem/common providers)
+        if (code === "ACTION_REJECTED")
+            return true;
+        if (name === "UserRejectedRequestError")
+            return true;
+        if (/user rejected/i.test(message))
+            return true;
+        // Terminal waitForViemTransactionWithRetry error (retries exhausted)
+        if (/Transaction failed after\s+\d+\s+attempts:/i.test(message)) {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+function sentryAddBreadcrumb(breadcrumb) {
+    try {
+        if (!isEnabled)
+            return;
+        getSentry()?.addBreadcrumb?.(breadcrumb);
+    }
+    catch { }
+}
+function sentryCaptureException(error, extra) {
+    try {
+        if (!isEnabled)
+            return;
+        if (shouldSkipSentry(error))
+            return;
+        const client = getSentry();
+        if (!client)
+            return;
+        const merged = extra ? { ...defaultExtra, ...extra } : defaultExtra;
+        client.captureException(error, Object.keys(merged).length ? { extra: merged } : undefined);
+    }
+    catch { }
+}
+
 exports.ForwarderError = void 0;
 (function (ForwarderError) {
     ForwarderError["CONTRACT_NOT_AVAILABLE"] = "Contract not available";
@@ -686,6 +750,22 @@ function useForwarder(signer, CHAIN_ID) {
             const tokenContract = getTokenContract(currency);
             if (!tokenContract)
                 throw new Error(exports.ForwarderError.CONTRACT_NOT_AVAILABLE);
+            sentryAddBreadcrumb({
+                category: "forwarder",
+                message: "forwardTokens.start",
+                level: "info",
+                data: {
+                    chainId: CHAIN_ID,
+                    type: params.type,
+                    amount: amount.toString(),
+                    currency,
+                    applicationId: params.applicationId,
+                    farmId: params.farmId,
+                    regionId: params.regionId,
+                    kickstarterId: params.kickstarterId,
+                    userAddress: params.userAddress,
+                },
+            });
             const owner = await signer.getAddress();
             // Construct the appropriate message for this forward type
             const message = constructForwardMessage(params);
@@ -708,6 +788,13 @@ function useForwarder(signer, CHAIN_ID) {
                     await waitForEthersTransactionWithRetry(signer, approveTx.hash);
                 }
                 catch (approveError) {
+                    sentryCaptureException(approveError, {
+                        action: "forwardTokens.approve",
+                        chainId: CHAIN_ID,
+                        spender: ADDRESSES.FORWARDER,
+                        amount: ethers.MaxUint256.toString(),
+                        currency,
+                    });
                     throw new Error(parseEthersError(approveError) || "Token approval failed");
                 }
             }
@@ -746,6 +833,17 @@ function useForwarder(signer, CHAIN_ID) {
                 }
             }
             catch (staticError) {
+                sentryCaptureException(staticError, {
+                    action: "forwardTokens.staticCall",
+                    chainId: CHAIN_ID,
+                    function: !isAuditFees && currency === "USDC"
+                        ? "swapUSDCAndForwardUSDG"
+                        : "forward",
+                    tokenAddress,
+                    amount: amount.toString(),
+                    currency,
+                    isAuditFees,
+                });
                 throw new Error(parseEthersError(staticError));
             }
             // Execute the forward transaction
@@ -762,6 +860,18 @@ function useForwarder(signer, CHAIN_ID) {
             return tx.hash;
         }
         catch (txError) {
+            sentryCaptureException(txError, {
+                action: "forwardTokens",
+                chainId: CHAIN_ID,
+                type: params.type,
+                amount: params.amount.toString(),
+                currency: params.currency ?? "USDC",
+                applicationId: params.applicationId,
+                farmId: params.farmId,
+                regionId: params.regionId,
+                kickstarterId: params.kickstarterId,
+                userAddress: params.userAddress,
+            });
             throw new Error(parseEthersError(txError));
         }
         finally {
@@ -1598,6 +1708,23 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
+            sentryAddBreadcrumb({
+                category: "offchain-fractions",
+                message: "createFraction.start",
+                level: "info",
+                data: {
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    id: params.id,
+                    token: params.token,
+                    step: params.step.toString(),
+                    totalSteps: params.totalSteps.toString(),
+                    to: params.to,
+                    expiration: params.expiration,
+                    minSharesToRaise: params.minSharesToRaise.toString(),
+                    closer: params.closer,
+                },
+            });
             const { id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise, closer, } = params;
             // Validate parameters
             if (!id || !token || !to) {
@@ -1630,6 +1757,12 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 });
             }
             catch (simulationError) {
+                sentryCaptureException(simulationError, {
+                    action: "createFraction.simulate",
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    id: params.id,
+                });
                 throw new Error(parseViemError(simulationError));
             }
             // Execute the transaction
@@ -1655,6 +1788,13 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
             return hash;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "createFraction",
+                chainId: walletClient?.chain?.id,
+                contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                id: params.id,
+                token: params.token,
+            });
             throw new Error(parseViemError(error));
         }
         finally {
@@ -1670,6 +1810,22 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
+            sentryAddBreadcrumb({
+                category: "offchain-fractions",
+                message: "buyFractions.start",
+                level: "info",
+                data: {
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    creator: params.creator,
+                    id: params.id,
+                    stepsToBuy: params.stepsToBuy.toString(),
+                    minStepsToBuy: params.minStepsToBuy.toString(),
+                    refundTo: params.refundTo,
+                    creditTo: params.creditTo,
+                    useCounterfactualAddressForRefund: params.useCounterfactualAddressForRefund,
+                },
+            });
             const { creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund, } = params;
             // Validate parameters
             if (!creator || !id || !refundTo || !creditTo) {
@@ -1725,6 +1881,13 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 });
             }
             catch (simulationError) {
+                sentryCaptureException(simulationError, {
+                    action: "buyFractions.simulate",
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    creator: params.creator,
+                    id: params.id,
+                });
                 throw new Error(parseViemError(simulationError));
             }
             // Execute the transaction
@@ -1748,6 +1911,14 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
             return hash;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "buyFractions",
+                chainId: walletClient?.chain?.id,
+                contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                creator: params.creator,
+                id: params.id,
+                stepsToBuy: params.stepsToBuy.toString(),
+            });
             throw new Error(parseViemError(error));
         }
         finally {
@@ -1765,6 +1936,18 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
+            sentryAddBreadcrumb({
+                category: "offchain-fractions",
+                message: "claimRefund.start",
+                level: "info",
+                data: {
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    user,
+                    creator,
+                    id,
+                },
+            });
             // Normalize addresses to lowercase for consistency
             const normalizedUser = user?.toLowerCase();
             const normalizedCreator = creator?.toLowerCase();
@@ -1810,7 +1993,14 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 });
             }
             catch (simulationError) {
-                console.error("Simulation failed:", simulationError);
+                sentryCaptureException(simulationError, {
+                    action: "claimRefund.simulate",
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    user,
+                    creator,
+                    id,
+                });
                 throw new Error(parseViemError(simulationError));
             }
             // Execute the transaction
@@ -1826,6 +2016,14 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
             return hash;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "claimRefund",
+                chainId: walletClient?.chain?.id,
+                contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                user,
+                creator,
+                id,
+            });
             throw new Error(parseViemError(error));
         }
         finally {
@@ -1842,6 +2040,17 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
+            sentryAddBreadcrumb({
+                category: "offchain-fractions",
+                message: "closeFraction.start",
+                level: "info",
+                data: {
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    creator,
+                    id,
+                },
+            });
             // Validate parameters
             if (!creator || !id) {
                 throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
@@ -1861,6 +2070,13 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 });
             }
             catch (simulationError) {
+                sentryCaptureException(simulationError, {
+                    action: "closeFraction.simulate",
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    creator,
+                    id,
+                });
                 throw new Error(parseViemError(simulationError));
             }
             // Execute the transaction
@@ -1876,6 +2092,13 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
             return hash;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "closeFraction",
+                chainId: walletClient?.chain?.id,
+                contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                creator,
+                id,
+            });
             throw new Error(parseViemError(error));
         }
         finally {
@@ -1998,6 +2221,19 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
+            sentryAddBreadcrumb({
+                category: "offchain-fractions",
+                message: "setRefundDetails.start",
+                level: "info",
+                data: {
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    creator,
+                    id,
+                    refundTo,
+                    useCounterfactualAddress,
+                },
+            });
             // Validate parameters
             if (!creator || !id || !refundTo) {
                 throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
@@ -2022,6 +2258,13 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 });
             }
             catch (simulationError) {
+                sentryCaptureException(simulationError, {
+                    action: "setRefundDetails.simulate",
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    creator,
+                    id,
+                });
                 throw new Error(parseViemError(simulationError));
             }
             // Execute the transaction
@@ -2042,6 +2285,14 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
             return hash;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "setRefundDetails",
+                chainId: walletClient?.chain?.id,
+                contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                creator,
+                id,
+                refundTo,
+            });
             throw new Error(parseViemError(error));
         }
         finally {
@@ -2058,6 +2309,17 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
         assertPublicClient(publicClient);
         try {
             setIsProcessing(true);
+            sentryAddBreadcrumb({
+                category: "offchain-fractions",
+                message: "setRefundOperatorStatus.start",
+                level: "info",
+                data: {
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    refundOperator,
+                    isApproved,
+                },
+            });
             // Validate parameters
             if (!refundOperator) {
                 throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
@@ -2077,6 +2339,13 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
                 });
             }
             catch (simulationError) {
+                sentryCaptureException(simulationError, {
+                    action: "setRefundOperatorStatus.simulate",
+                    chainId: walletClient?.chain?.id,
+                    contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    refundOperator,
+                    isApproved,
+                });
                 throw new Error(parseViemError(simulationError));
             }
             // Execute the transaction
@@ -2092,6 +2361,13 @@ function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
             return hash;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "setRefundOperatorStatus",
+                chainId: walletClient?.chain?.id,
+                contract: ADDRESSES.OFFCHAIN_FRACTIONS,
+                refundOperator,
+                isApproved,
+            });
             throw new Error(parseViemError(error));
         }
         finally {
@@ -2529,6 +2805,16 @@ function ControlRouter(baseUrl) {
     const stakeGctl = async (stakeRequest) => {
         isStaking = true;
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /stake",
+                level: "info",
+                data: {
+                    baseUrl,
+                    wallet: stakeRequest.wallet,
+                    regionId: stakeRequest.regionId,
+                },
+            });
             await request(`/stake`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -2537,6 +2823,14 @@ function ControlRouter(baseUrl) {
             return true;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "stakeGctl",
+                baseUrl,
+                wallet: stakeRequest.wallet,
+                regionId: stakeRequest.regionId,
+                amount: stakeRequest.amount,
+                deadline: stakeRequest.deadline,
+            });
             throw new Error(parseApiError$4(error));
         }
         finally {
@@ -2546,6 +2840,16 @@ function ControlRouter(baseUrl) {
     const unstakeGctl = async (unstakeRequest) => {
         isUnstaking = true;
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /unstake",
+                level: "info",
+                data: {
+                    baseUrl,
+                    wallet: unstakeRequest.wallet,
+                    regionId: unstakeRequest.regionId,
+                },
+            });
             await request(`/unstake`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -2554,6 +2858,14 @@ function ControlRouter(baseUrl) {
             return true;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "unstakeGctl",
+                baseUrl,
+                wallet: unstakeRequest.wallet,
+                regionId: unstakeRequest.regionId,
+                amount: unstakeRequest.amount,
+                deadline: unstakeRequest.deadline,
+            });
             throw new Error(parseApiError$4(error));
         }
         finally {
@@ -2563,6 +2875,17 @@ function ControlRouter(baseUrl) {
     const restakeGctl = async (restakeRequest) => {
         isRestaking = true;
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /restake",
+                level: "info",
+                data: {
+                    baseUrl,
+                    wallet: restakeRequest.wallet,
+                    fromZoneId: restakeRequest.fromZoneId,
+                    toZoneId: restakeRequest.toZoneId,
+                },
+            });
             await request(`/restake`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -2571,6 +2894,15 @@ function ControlRouter(baseUrl) {
             return true;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "restakeGctl",
+                baseUrl,
+                wallet: restakeRequest.wallet,
+                fromZoneId: restakeRequest.fromZoneId,
+                toZoneId: restakeRequest.toZoneId,
+                amount: restakeRequest.amount,
+                deadline: restakeRequest.deadline,
+            });
             throw new Error(parseApiError$4(error));
         }
         finally {
@@ -2580,6 +2912,12 @@ function ControlRouter(baseUrl) {
     const retryFailedOperation = async (operationId) => {
         isRetryingFailedOperation = true;
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /operations/failed/:id/retry",
+                level: "info",
+                data: { baseUrl, operationId },
+            });
             await request(`/operations/failed/${operationId}/retry`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -2587,6 +2925,11 @@ function ControlRouter(baseUrl) {
             return true;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "retryFailedOperation",
+                baseUrl,
+                operationId,
+            });
             throw new Error(parseApiError$4(error));
         }
         finally {
@@ -2596,6 +2939,18 @@ function ControlRouter(baseUrl) {
     const payProtocolDepositUsingStakedControl = async (paymentRequest) => {
         isPayingProtocolDepositUsingStakedControl = true;
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /pay-protocol-deposit-staked",
+                level: "info",
+                data: {
+                    baseUrl,
+                    wallet: paymentRequest.wallet,
+                    regionId: paymentRequest.regionId,
+                    applicationId: paymentRequest.applicationId,
+                    amount: paymentRequest.amount,
+                },
+            });
             const response = await request(`/pay-protocol-deposit-staked`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -2604,6 +2959,14 @@ function ControlRouter(baseUrl) {
             return response;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "payProtocolDepositUsingStakedControl",
+                baseUrl,
+                wallet: paymentRequest.wallet,
+                regionId: paymentRequest.regionId,
+                applicationId: paymentRequest.applicationId,
+                amount: paymentRequest.amount,
+            });
             throw new Error(parseApiError$4(error));
         }
         finally {
@@ -2613,6 +2976,15 @@ function ControlRouter(baseUrl) {
     const migrateUser = async (migrateRequest) => {
         isMigratingUser = true;
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /migrate-user",
+                level: "info",
+                data: {
+                    baseUrl,
+                    wallet: migrateRequest.wallet,
+                },
+            });
             const response = await request(`/migrate-user`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -2621,6 +2993,12 @@ function ControlRouter(baseUrl) {
             return response;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "migrateUser",
+                baseUrl,
+                wallet: migrateRequest.wallet,
+                deadline: migrateRequest.deadline,
+            });
             throw new Error(parseApiError$4(error));
         }
         finally {
@@ -3394,7 +3772,6 @@ function RegionRouter(baseUrl) {
     // -------------------------------------------------------------------------
     let cachedRegions = [];
     let isLoading = false;
-    let isCreatingRegion = false;
     // -------------------------------------------------------------------------
     // Queries
     // -------------------------------------------------------------------------
@@ -3451,27 +3828,6 @@ function RegionRouter(baseUrl) {
             throw new Error(parseApiError$3(error));
         }
     };
-    // -------------------------------------------------------------------------
-    // Mutations
-    // -------------------------------------------------------------------------
-    const createRegion = async (payload) => {
-        isCreatingRegion = true;
-        try {
-            await request(`/regions/create`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(payload),
-            });
-            // Refresh the local cache after successful creation
-            await fetchRegions();
-        }
-        catch (error) {
-            throw new Error(parseApiError$3(error));
-        }
-        finally {
-            isCreatingRegion = false;
-        }
-    };
     // Kickstarter-related logic moved to kickstarter-router.ts
     // -------------------------------------------------------------------------
     // Helpers (derived)
@@ -3520,7 +3876,6 @@ function RegionRouter(baseUrl) {
         fetchRegionByIdOrSlug,
         fetchRegionSolarFarms,
         getRegionByCode,
-        createRegion,
         // Cached data & flags
         get regions() {
             return cachedRegions;
@@ -3528,9 +3883,6 @@ function RegionRouter(baseUrl) {
         get isLoading() {
             return isLoading;
         },
-        get isCreatingRegion() {
-            return isCreatingRegion;
-        },
     };
 }
 
@@ -3566,6 +3918,16 @@ function KickstarterRouter(baseUrl) {
     const createKickstarter = async (payload) => {
         isCreatingKickstarter = true;
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /kickstarters",
+                level: "info",
+                data: {
+                    baseUrl,
+                    code: payload.code,
+                    creatorWallet: payload.creatorWallet,
+                },
+            });
             const exists = Boolean(regionMetadata[payload.code]);
             if (!exists) {
                 throw new Error(`Unknown region code: ${payload.code}`);
@@ -3578,6 +3940,14 @@ function KickstarterRouter(baseUrl) {
             return data;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "createKickstarter",
+                baseUrl,
+                code: payload.code,
+                creatorWallet: payload.creatorWallet,
+                title: payload.title,
+                regionName: payload.regionName,
+            });
             throw new Error(parseApiError$2(error));
         }
         finally {
@@ -3604,6 +3974,12 @@ function KickstarterRouter(baseUrl) {
     };
     const commitKickstarter = async (kickstarterId, payload) => {
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /kickstarters/commit/:id",
+                level: "info",
+                data: { baseUrl, kickstarterId },
+            });
             const data = await request(`/kickstarters/commit/${encodeURIComponent(kickstarterId)}`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -3612,6 +3988,13 @@ function KickstarterRouter(baseUrl) {
             return data;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "commitKickstarter",
+                baseUrl,
+                kickstarterId,
+                wallet: payload.wallet,
+                amount: payload.amount,
+            });
             throw new Error(parseApiError$2(error));
         }
     };
@@ -3778,6 +4161,12 @@ function FarmsRouter(baseUrl) {
     };
     const estimateRewardScore = async (params) => {
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /farms/estimate-reward-score",
+                level: "info",
+                data: { baseUrl, regionId: params.regionId, userId: params.userId },
+            });
             const data = await request("/farms/estimate-reward-score", {
                 method: "POST",
                 headers: {
@@ -3794,11 +4183,24 @@ function FarmsRouter(baseUrl) {
             return data;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "estimateRewardScore",
+                baseUrl,
+                userId: params.userId,
+                regionId: params.regionId,
+                paymentCurrency: params.paymentCurrency,
+            });
             throw new Error(parseApiError(error));
         }
     };
     const estimateRewardScoresBatch = async (params) => {
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /farms/estimate-reward-scores-batch",
+                level: "info",
+                data: { baseUrl },
+            });
             const data = await request("/farms/estimate-reward-scores-batch", {
                 method: "POST",
                 headers: {
@@ -3809,11 +4211,22 @@ function FarmsRouter(baseUrl) {
             return data;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "estimateRewardScoresBatch",
+                baseUrl,
+                farmsCount: params.farms?.length,
+            });
             throw new Error(parseApiError(error));
         }
     };
     const calculateMiningScoresBatch = async (params) => {
         try {
+            sentryAddBreadcrumb({
+                category: "control-api",
+                message: "POST /farms/mining-scores-batch",
+                level: "info",
+                data: { baseUrl },
+            });
             const data = await request("/farms/mining-scores-batch", {
                 method: "POST",
                 headers: {
@@ -3824,6 +4237,11 @@ function FarmsRouter(baseUrl) {
             return data;
         }
         catch (error) {
+            sentryCaptureException(error, {
+                action: "calculateMiningScoresBatch",
+                baseUrl,
+                farmsCount: params.farms?.length,
+            });
             throw new Error(parseApiError(error));
         }
     };
@@ -3854,6 +4272,7 @@ exports.TRANSFER_TYPES = TRANSFER_TYPES;
 exports.USDG_WEIGHT_DECIMAL_PRECISION = USDG_WEIGHT_DECIMAL_PRECISION;
 exports.WalletsRouter = WalletsRouter;
 exports.allRegions = allRegions;
+exports.configureSentry = configureSentry;
 exports.countries = countries;
 exports.getAddresses = getAddresses;
 exports.parseEthersError = parseEthersError;
@@ -3864,4 +4283,4 @@ exports.useForwarder = useForwarder;
 exports.useOffchainFractions = useOffchainFractions;
 exports.waitForEthersTransactionWithRetry = waitForEthersTransactionWithRetry;
 exports.waitForViemTransactionWithRetry = waitForViemTransactionWithRetry;
-//# sourceMappingURL=farms-router-CCva--xp.js.map
+//# sourceMappingURL=farms-router-C8V_F0vY.js.map