@sodax/dapp-kit 0.0.1-rc.8 → 1.0.0-rc.1

package/dist/index.js

@@ -2,9 +2,9 @@
 
 var React = require('react');
 var sdk = require('@sodax/sdk');
-var walletSdk = require('@sodax/wallet-sdk');
 var reactQuery = require('@tanstack/react-query');
 var viem = require('viem');
+var types = require('@sodax/types');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -19,54 +19,165 @@ var useSodaxContext = () => {
   }
   return context;
 };
+function useEstimateGas(spokeProvider) {
+  return reactQuery.useMutation({
+    mutationFn: async (rawTx) => {
+      if (!spokeProvider) {
+        throw new Error("spokeProvider is not found");
+      }
+      const response = await sdk.SpokeService.estimateGas(rawTx, spokeProvider);
+      return response;
+    }
+  });
+}
+function useDeriveUserWalletAddress(spokeProvider, walletAddress) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["deriveUserWalletAddress", spokeProvider?.chainConfig.chain.id, walletAddress],
+    queryFn: async () => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider is required");
+      }
+      return await sdk.deriveUserWalletAddress(spokeProvider, sodax.hubProvider, walletAddress);
+    },
+    enabled: !!spokeProvider,
+    refetchInterval: false
+    // This is a deterministic operation, no need to refetch
+  });
+}
+function useStellarTrustlineCheck(token, amount, spokeProvider, chainId) {
+  return reactQuery.useQuery({
+    queryKey: ["stellar-trustline-check", token],
+    queryFn: async () => {
+      if (chainId !== sdk.STELLAR_MAINNET_CHAIN_ID) {
+        return true;
+      }
+      if (!spokeProvider || !token || !amount || !(spokeProvider instanceof sdk.StellarSpokeProvider)) {
+        console.error(
+          "Spoke provider, token or amount not found. Details: spokeProvider:",
+          spokeProvider,
+          "token:",
+          token,
+          "amount:",
+          amount
+        );
+        return false;
+      }
+      const response = await sdk.StellarSpokeService.hasSufficientTrustline(token, amount, spokeProvider);
+      return response;
+    },
+    enabled: !!spokeProvider && !!token && !!amount
+  });
+}
+function useRequestTrustline(token) {
+  const queryClient = reactQuery.useQueryClient();
+  const [isLoading, setIsLoading] = React.useState(false);
+  const [isRequested, setIsRequested] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const [data, setData] = React.useState(null);
+  const requestTrustline = React.useCallback(
+    async ({
+      token: token2,
+      amount,
+      spokeProvider
+    }) => {
+      if (!spokeProvider || !token2 || !amount || !(spokeProvider instanceof sdk.StellarSpokeProvider)) {
+        const error2 = new Error("Spoke provider, token or amount not found");
+        setError(error2);
+        throw error2;
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await sdk.StellarSpokeService.requestTrustline(token2, amount, spokeProvider);
+        setData(result);
+        setIsRequested(true);
+        queryClient.invalidateQueries({ queryKey: ["stellar-trustline-check", token2] });
+        return result;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [queryClient]
+  );
+  return {
+    requestTrustline,
+    isLoading,
+    isRequested,
+    error,
+    data
+  };
+}
 
 // src/hooks/provider/useHubProvider.ts
 function useHubProvider() {
-  const { hubProvider } = useSodaxContext();
-  return hubProvider;
+  const { sodax } = useSodaxContext();
+  return sodax.hubProvider;
 }
 function useSpokeProvider(spokeChainId, walletProvider) {
-  const xChainType = walletSdk.getXChainType(spokeChainId);
-  const walletProvider_ = walletSdk.useWalletProvider(spokeChainId);
-  const _walletProvider = walletProvider ?? walletProvider_;
+  const { rpcConfig } = useSodaxContext();
+  const xChainType = spokeChainId ? sdk.spokeChainConfig[spokeChainId]?.chain.type : void 0;
   const spokeProvider = React.useMemo(() => {
-    if (!_walletProvider) return void 0;
+    if (!walletProvider) return void 0;
     if (!spokeChainId) return void 0;
+    if (!xChainType) return void 0;
+    if (!rpcConfig) return void 0;
     if (xChainType === "EVM") {
+      if (spokeChainId === sdk.SONIC_MAINNET_CHAIN_ID) {
+        return new sdk.SonicSpokeProvider(
+          walletProvider,
+          sdk.spokeChainConfig[spokeChainId]
+        );
+      }
       return new sdk.EvmSpokeProvider(
-        _walletProvider,
+        walletProvider,
         sdk.spokeChainConfig[spokeChainId]
       );
     }
     if (xChainType === "SUI") {
       return new sdk.SuiSpokeProvider(
         sdk.spokeChainConfig[spokeChainId],
-        _walletProvider
+        walletProvider
       );
     }
     if (xChainType === "ICON") {
       return new sdk.IconSpokeProvider(
-        _walletProvider,
+        walletProvider,
         sdk.spokeChainConfig[spokeChainId]
       );
     }
     if (xChainType === "INJECTIVE") {
-      return new sdk.CWSpokeProvider(
+      return new sdk.InjectiveSpokeProvider(
         sdk.spokeChainConfig[spokeChainId],
-        _walletProvider
+        walletProvider
       );
     }
     if (xChainType === "STELLAR") {
       const stellarConfig = sdk.spokeChainConfig[spokeChainId];
       return new sdk.StellarSpokeProvider(
-        _walletProvider,
-        stellarConfig.addresses.assetManager,
+        walletProvider,
         stellarConfig,
-        stellarConfig.rpc_url
+        rpcConfig.stellar ? rpcConfig.stellar : {
+          horizonRpcUrl: stellarConfig.horizonRpcUrl,
+          sorobanRpcUrl: stellarConfig.sorobanRpcUrl
+        }
+      );
+    }
+    if (xChainType === "SOLANA") {
+      return new sdk.SolanaSpokeProvider(
+        walletProvider,
+        rpcConfig.solana ? {
+          ...sdk.spokeChainConfig[spokeChainId],
+          rpcUrl: rpcConfig.solana
+        } : sdk.spokeChainConfig[spokeChainId]
       );
     }
     return void 0;
-  }, [spokeChainId, xChainType, _walletProvider]);
+  }, [spokeChainId, xChainType, walletProvider, rpcConfig]);
   return spokeProvider;
 }
 function useBorrow(spokeToken, spokeProvider) {
@@ -76,7 +187,7 @@ function useBorrow(spokeToken, spokeProvider) {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.borrowAndSubmit(
+      const response = await sodax.moneyMarket.borrow(
         {
           token: spokeToken.address,
           amount: viem.parseUnits(amount, 18),
@@ -99,7 +210,7 @@ function useRepay(spokeToken, spokeProvider) {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.repayAndSubmit(
+      const response = await sodax.moneyMarket.repay(
         {
           token: spokeToken.address,
           amount: viem.parseUnits(amount, spokeToken.decimals),
@@ -122,7 +233,7 @@ function useSupply(spokeToken, spokeProvider) {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.supplyAndSubmit(
+      const response = await sodax.moneyMarket.supply(
         {
           token: spokeToken.address,
           amount: viem.parseUnits(amount, spokeToken.decimals),
@@ -145,7 +256,7 @@ function useWithdraw(spokeToken, spokeProvider) {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.withdrawAndSubmit(
+      const response = await sodax.moneyMarket.withdraw(
         {
           token: spokeToken.address,
           // vault token on hub chain decimals is 18
@@ -162,97 +273,26 @@ function useWithdraw(spokeToken, spokeProvider) {
     }
   });
 }
-var allXTokens = [];
-Object.keys(sdk.hubAssets).forEach((xChainId) => {
-  const tokens = sdk.hubAssets[xChainId];
-  Object.keys(tokens).forEach((tokenAddress) => {
-    const token = tokens[tokenAddress];
-    allXTokens.push({
-      xChainId,
-      symbol: token.symbol,
-      name: token.name,
-      decimals: token.decimal,
-      address: tokenAddress
-    });
-    allXTokens.push({
-      xChainId: "sonic",
-      symbol: token.symbol,
-      name: token.name,
-      decimals: token.decimal,
-      address: token.vault
-    });
-  });
-});
-var getSpokeTokenAddressByVault = (spokeChainId, vault) => {
-  const tokens = sdk.hubAssets[spokeChainId];
-  const address = Object.keys(tokens).find((tokenAddress) => tokens[tokenAddress].vault === vault);
-  return address;
-};
-function useUserReservesData(spokeChainId, address) {
+function useUserReservesData(spokeProvider, address, refetchInterval = 5e3) {
   const { sodax } = useSodaxContext();
-  const hubChainId = sodax.config?.hubProviderConfig?.chainConfig.chain.id ?? "sonic";
-  const hubProvider = useHubProvider();
-  const { data: userReserves } = reactQuery.useQuery({
-    queryKey: ["userReserves", spokeChainId, address],
-    queryFn: async () => {
-      if (!hubProvider || !address) {
-        return;
-      }
-      const addressBytes = sdk.encodeAddress(spokeChainId, address);
-      const hubWalletAddress = await sdk.EvmWalletAbstraction.getUserHubWalletAddress(
-        spokeChainId,
-        addressBytes,
-        hubProvider
-      );
-      const moneyMarketConfig = sdk.getMoneyMarketConfig(hubChainId);
-      const [res] = await sodax.moneyMarket.getUserReservesData(
-        hubWalletAddress,
-        moneyMarketConfig.uiPoolDataProvider,
-        moneyMarketConfig.poolAddressesProvider
-      );
-      return res?.map((r) => {
-        return {
-          ...r,
-          token: allXTokens.find((t) => t.address === r.underlyingAsset)
-        };
-      });
-    },
-    enabled: !!spokeChainId && !!hubProvider && !!address,
-    refetchInterval: 5e3
-  });
-  return userReserves;
-}
-function useHubWalletAddress(spokeChainId, address, hubProvider) {
   return reactQuery.useQuery({
-    queryKey: ["hubWallet", spokeChainId, address],
+    queryKey: ["userReserves", spokeProvider?.chainConfig.chain.id, address],
     queryFn: async () => {
-      if (!address) return null;
-      try {
-        const hubWalletAddress = await sdk.EvmWalletAbstraction.getUserHubWalletAddress(
-          spokeChainId,
-          address,
-          hubProvider
-        );
-        return hubWalletAddress;
-      } catch (error) {
-        console.log("error", error);
-        return null;
+      if (!spokeProvider) {
+        throw new Error("Spoke provider or address is not defined");
       }
+      return await sodax.moneyMarket.data.getUserReservesData(spokeProvider);
     },
-    enabled: !!address && !!hubProvider
+    enabled: !!spokeProvider && !!address,
+    refetchInterval
   });
 }
 function useReservesData() {
   const { sodax } = useSodaxContext();
-  const hubChainId = sodax.config?.hubProviderConfig?.chainConfig.chain.id ?? "sonic";
   return reactQuery.useQuery({
     queryKey: ["reservesData"],
     queryFn: async () => {
-      const moneyMarketConfig = sdk.getMoneyMarketConfig(hubChainId);
-      return await sodax.moneyMarket.getReservesData(
-        moneyMarketConfig.uiPoolDataProvider,
-        moneyMarketConfig.poolAddressesProvider
-      );
+      return await sodax.moneyMarket.data.getReservesData();
     }
   });
 }
@@ -262,10 +302,11 @@ function useMMAllowance(token, amount, action, spokeProvider) {
     queryKey: ["allowance", token.address, amount, action],
     queryFn: async () => {
       if (!spokeProvider) throw new Error("Spoke provider is required");
+      const actionBasedDecimals = action === "withdraw" || action === "borrow" ? 18 : token.decimals;
       const allowance = await sodax.moneyMarket.isAllowanceValid(
         {
           token: token.address,
-          amount: viem.parseUnits(amount, token.decimals),
+          amount: viem.parseUnits(amount, actionBasedDecimals),
           action
         },
         spokeProvider
@@ -291,10 +332,11 @@ function useMMApprove(token, spokeProvider) {
       if (!spokeProvider) {
         throw new Error("Spoke provider not found");
       }
+      const actionBasedDecimals = action === "withdraw" || action === "borrow" ? 18 : token.decimals;
       const allowance = await sodax.moneyMarket.approve(
         {
           token: token.address,
-          amount: viem.parseUnits(amount, token.decimals),
+          amount: viem.parseUnits(amount, actionBasedDecimals),
           action
         },
         spokeProvider
@@ -317,26 +359,43 @@ function useMMApprove(token, spokeProvider) {
 }
 var useQuote = (payload) => {
   const { sodax } = useSodaxContext();
+  const queryKey = React.useMemo(() => {
+    if (!payload) return ["quote", void 0];
+    return [
+      "quote",
+      {
+        ...payload,
+        amount: payload.amount.toString()
+      }
+    ];
+  }, [payload]);
   return reactQuery.useQuery({
-    queryKey: [payload],
+    queryKey,
     queryFn: async () => {
       if (!payload) {
         return void 0;
       }
-      return sodax.solver.getQuote(payload);
+      return sodax.swap.getQuote(payload);
     },
     enabled: !!payload,
     refetchInterval: 3e3
   });
 };
-function useCreateIntentOrder(spokeProvider) {
+function useSwap(spokeProvider) {
   const { sodax } = useSodaxContext();
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     mutationFn: async (params) => {
       if (!spokeProvider) {
         throw new Error("Spoke provider not found");
       }
-      return sodax.solver.createAndSubmitIntent(params, spokeProvider);
+      return sodax.swap.swap({
+        intentParams: params,
+        spokeProvider
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["xBalances"] });
     }
   });
 }
@@ -345,7 +404,7 @@ var useStatus = (intent_tx_hash) => {
   return reactQuery.useQuery({
     queryKey: [intent_tx_hash],
     queryFn: async () => {
-      return sodax.solver.getStatus({ intent_tx_hash });
+      return sodax.swap.getStatus({ intent_tx_hash });
     },
     refetchInterval: 3e3
     // 3s
@@ -359,16 +418,20 @@ function useSwapAllowance(params, spokeProvider) {
       if (!spokeProvider || !params) {
         return false;
       }
-      const allowance = await sodax.solver.isAllowanceValid(params, spokeProvider);
+      const allowance = await sodax.swap.isAllowanceValid({
+        intentParams: params,
+        spokeProvider
+      });
       if (allowance.ok) {
         return allowance.value;
       }
       return false;
     },
-    enabled: !!spokeProvider && !!params
+    enabled: !!spokeProvider && !!params,
+    refetchInterval: 2e3
   });
 }
-function useSwapApprove(token, spokeProvider) {
+function useSwapApprove(params, spokeProvider) {
   const { sodax } = useSodaxContext();
   const queryClient = reactQuery.useQueryClient();
   const {
@@ -377,25 +440,24 @@ function useSwapApprove(token, spokeProvider) {
     error,
     reset: resetError
   } = reactQuery.useMutation({
-    mutationFn: async ({ amount }) => {
+    mutationFn: async ({ params: params2 }) => {
       if (!spokeProvider) {
         throw new Error("Spoke provider not found");
       }
-      if (!token) {
-        throw new Error("Token not found");
+      if (!params2) {
+        throw new Error("Swap Params not found");
       }
-      const allowance = await sodax.solver.approve(
-        token.address,
-        viem.parseUnits(amount, token.decimals),
+      const allowance = await sodax.swap.approve({
+        intentParams: params2,
         spokeProvider
-      );
+      });
       if (!allowance.ok) {
-        throw new Error("Failed to approve tokens");
+        throw new Error("Failed to approve input token");
       }
       return allowance.ok;
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["allowance", token?.address] });
+      queryClient.invalidateQueries({ queryKey: ["allowance", params] });
     }
   });
   return {
@@ -405,41 +467,852 @@ function useSwapApprove(token, spokeProvider) {
     resetError
   };
 }
-var SodaxProvider = ({ children, testnet = false, config }) => {
-  const sodax = new sdk.Sodax(config);
-  const hubChainId = config?.hubProviderConfig?.chainConfig.chain.id;
-  const hubRpcUrl = config?.hubProviderConfig?.hubRpcUrl;
-  const hubProvider = React.useMemo(() => {
-    if (hubChainId && hubRpcUrl) {
-      const hubChainCfg = sdk.getHubChainConfig(hubChainId);
-      return new sdk.EvmHubProvider({
-        hubRpcUrl,
-        chainConfig: hubChainCfg
+function useCancelSwap(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async ({ intent, raw = false }) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      return sodax.swap.cancelIntent(intent, spokeProvider, raw);
+    }
+  });
+}
+var useBackendIntentByTxHash = (txHash) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "intent", "txHash", txHash],
+    queryFn: async () => {
+      if (!txHash) {
+        return void 0;
+      }
+      return sodax.backendApi.getIntentByTxHash(txHash);
+    },
+    enabled: !!txHash && txHash.length > 0,
+    retry: 3
+  });
+};
+var useBackendIntentByHash = (intentHash) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "intent", "hash", intentHash],
+    queryFn: async () => {
+      if (!intentHash) {
+        return void 0;
+      }
+      return sodax.backendApi.getIntentByHash(intentHash);
+    },
+    enabled: !!intentHash && intentHash.length > 0,
+    retry: 3
+  });
+};
+var useBackendOrderbook = (params) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "solver", "orderbook", params],
+    queryFn: async () => {
+      if (!params || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApi.getOrderbook(params);
+    },
+    enabled: !!params && !!params.offset && !!params.limit,
+    staleTime: 30 * 1e3,
+    // 30 seconds for real-time data
+    retry: 3
+  });
+};
+var useBackendMoneyMarketPosition = (userAddress) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "position", userAddress],
+    queryFn: async () => {
+      if (!userAddress) {
+        return void 0;
+      }
+      return sodax.backendApi.getMoneyMarketPosition(userAddress);
+    },
+    enabled: !!userAddress && userAddress.length > 0,
+    retry: 3
+  });
+};
+var useBackendAllMoneyMarketAssets = () => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "assets", "all"],
+    queryFn: async () => {
+      return sodax.backendApi.getAllMoneyMarketAssets();
+    },
+    retry: 3
+  });
+};
+var useBackendMoneyMarketAsset = (reserveAddress) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "asset", reserveAddress],
+    queryFn: async () => {
+      if (!reserveAddress) {
+        return void 0;
+      }
+      return sodax.backendApi.getMoneyMarketAsset(reserveAddress);
+    },
+    enabled: !!reserveAddress && reserveAddress.length > 0,
+    retry: 3
+  });
+};
+var useBackendMoneyMarketAssetBorrowers = (params) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "asset", "borrowers", params],
+    queryFn: async () => {
+      if (!params.reserveAddress || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApi.getMoneyMarketAssetBorrowers(params.reserveAddress, {
+        offset: params.offset,
+        limit: params.limit
+      });
+    },
+    enabled: !!params.reserveAddress && !!params.offset && !!params.limit,
+    retry: 3
+  });
+};
+var useBackendMoneyMarketAssetSuppliers = (params) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "asset", "suppliers", params],
+    queryFn: async () => {
+      if (!params.reserveAddress || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApi.getMoneyMarketAssetSuppliers(params.reserveAddress, {
+        offset: params.offset,
+        limit: params.limit
+      });
+    },
+    enabled: !!params.reserveAddress && !!params.offset && !!params.limit,
+    retry: 3
+  });
+};
+var useBackendAllMoneyMarketBorrowers = (params) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "borrowers", "all", params],
+    queryFn: async () => {
+      if (!params || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApi.getAllMoneyMarketBorrowers(params);
+    },
+    enabled: !!params && !!params.offset && !!params.limit,
+    retry: 3
+  });
+};
+function useBridgeAllowance(params, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["bridge-allowance", params],
+    queryFn: async () => {
+      if (!spokeProvider || !params) {
+        return false;
+      }
+      const allowance = await sodax.bridge.isAllowanceValid({
+        params,
+        spokeProvider
+      });
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider && !!params
+  });
+}
+function useBridgeApprove(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  const queryClient = reactQuery.useQueryClient();
+  const {
+    mutateAsync: approve,
+    isPending,
+    error,
+    reset: resetError
+  } = reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const allowance = await sodax.bridge.approve({
+        params,
+        spokeProvider
       });
+      if (!allowance.ok) {
+        throw new Error("Failed to approve tokens for bridge");
+      }
+      return true;
+    },
+    onSuccess: (_, params) => {
+      queryClient.invalidateQueries({ queryKey: ["bridge-allowance", params] });
     }
-    return void 0;
-  }, [hubChainId, hubRpcUrl]);
-  return /* @__PURE__ */ React__default.default.createElement(SodaxContext.Provider, { value: { sodax, testnet, hubProvider } }, children);
+  });
+  return {
+    approve,
+    isLoading: isPending,
+    error,
+    resetError
+  };
+}
+function useBridge(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const result = await sodax.bridge.bridge({
+        params,
+        spokeProvider
+      });
+      if (!result.ok) {
+        throw new Error(`Bridge failed: ${result.error.code}`);
+      }
+      return result;
+    }
+  });
+}
+function useGetBridgeableAmount(from, to) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["spoke-asset-manager-token-balance", from, to],
+    queryFn: async () => {
+      if (!from || !to) {
+        return 0n;
+      }
+      const result = await sodax.bridge.getBridgeableAmount(from, to);
+      if (result.ok) {
+        return result.value;
+      }
+      console.error("Error getting bridgeable amount:", result.error);
+      return 0n;
+    },
+    enabled: !!from && !!to
+  });
+}
+function useGetBridgeableTokens(from, to, token) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["bridgeable-tokens", from, to, token],
+    queryFn: async () => {
+      if (!from || !to || !token) {
+        return [];
+      }
+      const result = sodax.bridge.getBridgeableTokens(from, to, token);
+      if (result.ok) {
+        return result.value;
+      }
+      console.error("Error getting bridgeable tokens:", result.error);
+      return [];
+    },
+    enabled: !!from && !!to && !!token
+  });
+}
+function useStake(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const result = await sodax.staking.stake(params, spokeProvider);
+      if (!result.ok) {
+        throw new Error(`Stake failed: ${result.error.code}`);
+      }
+      return result.value;
+    }
+  });
+}
+function useStakeApprove(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const result = await sodax.staking.approve({
+        params: { ...params, action: "stake" },
+        spokeProvider
+      });
+      if (!result.ok) {
+        throw new Error(`Stake approval failed: ${result.error.code}`);
+      }
+      return result.value;
+    }
+  });
+}
+function useStakeAllowance(params, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["soda", "stakeAllowance", params, spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!params || !spokeProvider) {
+        return false;
+      }
+      const result = await sodax.staking.isAllowanceValid({
+        params: { ...params, action: "stake" },
+        spokeProvider
+      });
+      if (!result.ok) {
+        throw new Error(`Allowance check failed: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    enabled: !!params && !!spokeProvider,
+    refetchInterval: 5e3
+    // Refetch every 5 seconds
+  });
+}
+function useUnstake(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const result = await sodax.staking.unstake({ ...params, action: "unstake" }, spokeProvider);
+      if (!result.ok) {
+        throw new Error(`Unstake failed: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["stakingInfo"] });
+      queryClient.invalidateQueries({ queryKey: ["unstakingInfo"] });
+      queryClient.invalidateQueries({ queryKey: ["unstakingInfoWithPenalty"] });
+    }
+  });
+}
+function useClaim(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const result = await sodax.staking.claim({ ...params, action: "claim" }, spokeProvider);
+      if (!result.ok) {
+        throw new Error(`Claim failed: ${result.error.code}`);
+      }
+      return result.value;
+    }
+  });
+}
+function useCancelUnstake(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not available");
+      }
+      const result = await sodax.staking.cancelUnstake({ ...params, action: "cancelUnstake" }, spokeProvider);
+      if (!result.ok) {
+        throw new Error(`Cancel unstake failed: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["stakingInfo"] });
+      queryClient.invalidateQueries({ queryKey: ["unstakingInfo"] });
+      queryClient.invalidateQueries({ queryKey: ["unstakingInfoWithPenalty"] });
+    }
+  });
+}
+function useStakingInfo(spokeProvider, refetchInterval = 5e3) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["soda", "stakingInfo", spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const result = await sodax.staking.getStakingInfoFromSpoke(spokeProvider);
+      if (!result.ok) {
+        throw new Error(`Failed to fetch staking info: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    enabled: !!spokeProvider,
+    refetchInterval
+  });
+}
+function useUnstakingInfoWithPenalty(userAddress, spokeProvider, refetchInterval = 5e3) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["soda", "unstakingInfoWithPenalty", spokeProvider?.chainConfig.chain.id, userAddress],
+    queryFn: async () => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const penaltyResult = await sodax.staking.getUnstakingInfoWithPenalty(spokeProvider);
+      if (!penaltyResult.ok) {
+        throw new Error(`Failed to fetch unstaking info with penalty: ${penaltyResult.error.code}`);
+      }
+      return penaltyResult.value;
+    },
+    enabled: !!spokeProvider && !!userAddress,
+    refetchInterval
+  });
+}
+function useStakingConfig(refetchInterval = 3e4) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["soda", "stakingConfig"],
+    queryFn: async () => {
+      const result = await sodax.staking.getStakingConfig();
+      if (!result.ok) {
+        throw new Error(`Failed to fetch staking config: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    refetchInterval
+  });
+}
+function useStakeRatio(amount, refetchInterval = 1e4) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["soda", "stakeRatio", amount?.toString()],
+    queryFn: async () => {
+      if (!amount || amount <= 0n) {
+        throw new Error("Amount must be greater than 0");
+      }
+      if (!sodax?.staking) {
+        throw new Error("Staking service not available");
+      }
+      const result = await sodax.staking.getStakeRatio(amount);
+      if (!result.ok) {
+        throw new Error(`Failed to fetch stake ratio: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    enabled: !!amount && amount > 0n && !!sodax?.staking,
+    refetchInterval
+  });
+}
+function useInstantUnstakeRatio(amount, refetchInterval = 1e4) {
+  const { sodax } = useSodaxContext();
+  console.log("useInstantUnstakeRatio hook called with:", { amount: amount?.toString(), sodax: !!sodax });
+  return reactQuery.useQuery({
+    queryKey: ["soda", "instantUnstakeRatio", amount?.toString()],
+    queryFn: async () => {
+      console.log("useInstantUnstakeRatio queryFn called with amount:", amount?.toString());
+      if (!amount || amount <= 0n) {
+        throw new Error("Amount must be greater than 0");
+      }
+      if (!sodax?.staking) {
+        throw new Error("Staking service not available");
+      }
+      const result = await sodax.staking.getInstantUnstakeRatio(amount);
+      if (!result.ok) {
+        throw new Error(`Failed to fetch instant unstake ratio: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    enabled: !!amount && amount > 0n && !!sodax?.staking,
+    refetchInterval
+  });
+}
+function useConvertedAssets(amount, refetchInterval = 1e4) {
+  const { sodax } = useSodaxContext();
+  console.log("useConvertedAssets hook called with:", { amount: amount?.toString(), sodax: !!sodax });
+  return reactQuery.useQuery({
+    queryKey: ["soda", "convertedAssets", amount?.toString()],
+    queryFn: async () => {
+      console.log("useConvertedAssets queryFn called with amount:", amount?.toString());
+      if (!amount || amount <= 0n) {
+        throw new Error("Amount must be greater than 0");
+      }
+      const result = await sodax.staking.getConvertedAssets(amount);
+      if (!result.ok) {
+        throw new Error(`Failed to fetch converted assets: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    enabled: !!amount && amount > 0n && !!sodax?.staking,
+    refetchInterval
+  });
+}
+function useInstantUnstake(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("spokeProvider is not found");
+      }
+      const result = await sodax.staking.instantUnstake({ ...params, action: "instantUnstake" }, spokeProvider);
+      if (!result.ok) {
+        throw new Error(`Instant unstake failed: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    onError: (error) => {
+      console.error("Instant unstake error:", error);
+    }
+  });
+}
+function useUnstakeAllowance(params, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["soda", "unstakeAllowance", params, spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!params || !spokeProvider) {
+        return false;
+      }
+      const result = await sodax.staking.isAllowanceValid({
+        params: { ...params, action: "unstake" },
+        spokeProvider
+      });
+      if (!result.ok) {
+        console.error(`Unstake allowance check failed: ${result.error.code}, error: ${result.error.error}`);
+        throw new Error(`Unstake allowance check failed: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    enabled: !!params && !!spokeProvider,
+    refetchInterval: 5e3
+    // Refetch every 5 seconds
+  });
+}
+function useUnstakeApprove(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      console.log("useUnstakeApprove called with params:", params);
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const result = await sodax.staking.approve({
+        params: { ...params, action: "unstake" },
+        spokeProvider
+      });
+      if (!result.ok) {
+        throw new Error(`Unstake approval failed: ${result.error.code}`);
+      }
+      return result.value;
+    }
+  });
+}
+function useUnstakingInfo(userAddress, spokeProvider, refetchInterval = 5e3) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["soda", "unstakingInfoWithPenalty", spokeProvider?.chainConfig.chain.id, userAddress],
+    queryFn: async () => {
+      if (!spokeProvider || !userAddress) {
+        throw new Error("Spoke provider or user address not found");
+      }
+      const result = await sodax.staking.getUnstakingInfo(spokeProvider);
+      if (!result.ok) {
+        throw new Error(`Failed to fetch unstaking info: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    enabled: !!spokeProvider && !!userAddress,
+    refetchInterval
+  });
+}
+function useInstantUnstakeApprove(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      console.log("useInstantUnstakeApprove called with params:", params);
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const result = await sodax.staking.approve({
+        params: { ...params, action: "instantUnstake" },
+        spokeProvider
+      });
+      if (!result.ok) {
+        throw new Error(`Instant unstake approval failed: ${result.error.code}`);
+      }
+      return result.value;
+    }
+  });
+}
+function useInstantUnstakeAllowance(params, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["soda", "instantUnstakeAllowance", params, spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!params || !spokeProvider) {
+        return false;
+      }
+      const result = await sodax.staking.isAllowanceValid({
+        params: { ...params, action: "instantUnstake" },
+        spokeProvider
+      });
+      if (!result.ok) {
+        console.error(`Unstake allowance check failed: ${result.error.code}, error: ${result.error.error}`);
+        throw new Error(`Unstake allowance check failed: ${result.error.code}`);
+      }
+      return result.value;
+    },
+    enabled: !!params && !!spokeProvider,
+    refetchInterval: 5e3
+    // Refetch every 5 seconds
+  });
+}
+
+// src/hooks/migrate/types.ts
+var MIGRATION_MODE_ICX_SODA = "icxsoda";
+var MIGRATION_MODE_BNUSD = "bnusd";
+
+// src/hooks/migrate/useMigrate.tsx
+function useMigrate(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = params;
+      const amountToMigrate = viem.parseUnits(amount ?? "0", token?.decimals ?? 0);
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      if (migrationMode === MIGRATION_MODE_ICX_SODA) {
+        if (token?.xChainId === types.ICON_MAINNET_CHAIN_ID) {
+          const params2 = {
+            address: sdk.spokeChainConfig[types.ICON_MAINNET_CHAIN_ID].nativeToken,
+            amount: amountToMigrate,
+            to: destinationAddress
+          };
+          const result2 = await sodax.migration.migrateIcxToSoda(params2, spokeProvider, 3e4);
+          if (result2.ok) {
+            const [spokeTxHash, hubTxHash] = result2.value;
+            return { spokeTxHash, hubTxHash };
+          }
+          throw new Error("ICX to SODA migration failed. Please try again.");
+        }
+        const revertParams = {
+          amount: amountToMigrate,
+          to: destinationAddress
+        };
+        const result = await sodax.migration.revertMigrateSodaToIcx(
+          revertParams,
+          spokeProvider,
+          3e4
+        );
+        if (result.ok) {
+          const [hubTxHash, spokeTxHash] = result.value;
+          return { spokeTxHash, hubTxHash };
+        }
+        throw new Error("SODA to ICX migration failed. Please try again.");
+      }
+      if (migrationMode === MIGRATION_MODE_BNUSD) {
+        const params2 = {
+          srcChainId: token?.xChainId,
+          dstChainId: toToken?.xChainId,
+          srcbnUSD: token?.address,
+          dstbnUSD: toToken?.address,
+          amount: amountToMigrate,
+          to: destinationAddress
+        };
+        const result = await sodax.migration.migratebnUSD(params2, spokeProvider, 3e4);
+        if (result.ok) {
+          const [spokeTxHash, hubTxHash] = result.value;
+          return { spokeTxHash, hubTxHash };
+        }
+        const errorMessage = sdk.isLegacybnUSDToken(token?.address) ? "bnUSD migration failed. Please try again." : "bnUSD reverse migration failed. Please try again.";
+        throw new Error(errorMessage);
+      }
+      throw new Error("Invalid migration mode");
+    }
+  });
+}
+function useMigrationAllowance(params, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["migration-allowance", params],
+    queryFn: async () => {
+      if (!spokeProvider || !params) {
+        return false;
+      }
+      const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = params;
+      if (token?.xChainId === types.ICON_MAINNET_CHAIN_ID) {
+        return true;
+      }
+      if (!spokeProvider) throw new Error("Spoke provider is required");
+      const amountToMigrate = viem.parseUnits(amount ?? "0", token?.decimals ?? 0);
+      let migrationParams;
+      if (migrationMode === MIGRATION_MODE_ICX_SODA) {
+        migrationParams = {
+          amount: amountToMigrate,
+          to: destinationAddress
+        };
+      } else {
+        if (!toToken) throw new Error("Destination token is required for bnUSD migration");
+        migrationParams = {
+          srcChainId: token?.xChainId,
+          dstChainId: toToken?.xChainId,
+          srcbnUSD: token?.address,
+          dstbnUSD: toToken?.address,
+          amount: amountToMigrate,
+          to: destinationAddress
+        };
+      }
+      const allowance = await sodax.migration.isAllowanceValid(migrationParams, "revert", spokeProvider);
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider && !!params,
+    refetchInterval: 2e3
+  });
+}
+function useMigrationApprove(params, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  const [isLoading, setIsLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const [isApproved, setIsApproved] = React.useState(false);
+  const queryClient = reactQuery.useQueryClient();
+  const prevTokenAddress = React.useRef(void 0);
+  const prevAmount = React.useRef(void 0);
+  React.useEffect(() => {
+    if (prevTokenAddress.current !== params?.token?.address || prevAmount.current !== params?.amount) {
+      setIsApproved(false);
+      prevTokenAddress.current = params?.token?.address;
+      prevAmount.current = params?.amount;
+    }
+  }, [params?.token?.address, params?.amount]);
+  const approve = React.useCallback(
+    async ({ params: approveParams }) => {
+      try {
+        setIsLoading(true);
+        setError(null);
+        if (!spokeProvider) {
+          throw new Error("Spoke provider not found");
+        }
+        if (!approveParams) {
+          throw new Error("Migration intent not found");
+        }
+        const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = approveParams;
+        const amountToMigrate = viem.parseUnits(amount ?? "0", token?.decimals ?? 0);
+        let result;
+        if (migrationMode === MIGRATION_MODE_ICX_SODA) {
+          const revertParams = {
+            amount: amountToMigrate,
+            to: destinationAddress
+          };
+          result = await sodax.migration.approve(revertParams, "revert", spokeProvider, false);
+        } else if (migrationMode === MIGRATION_MODE_BNUSD) {
+          if (!toToken) throw new Error("Destination token is required for bnUSD migration");
+          const migrationParams = {
+            srcChainId: token?.xChainId,
+            dstChainId: toToken?.xChainId,
+            srcbnUSD: token?.address,
+            dstbnUSD: toToken?.address,
+            amount: amountToMigrate,
+            to: destinationAddress
+          };
+          result = await sodax.migration.approve(migrationParams, "revert", spokeProvider, false);
+        } else {
+          throw new Error("Invalid migration mode");
+        }
+        if (!result.ok) {
+          throw new Error("Failed to approve tokens");
+        }
+        setIsApproved(true);
+        queryClient.invalidateQueries({ queryKey: ["migration-allowance", params] });
+        return result.ok;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("An unknown error occurred");
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [spokeProvider, sodax, queryClient, params]
+  );
+  const resetError = React.useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    approve,
+    isLoading,
+    error,
+    resetError,
+    isApproved
+  };
+}
+var SodaxProvider = ({ children, testnet = false, config, rpcConfig }) => {
+  const sodax = new sdk.Sodax(config);
+  return /* @__PURE__ */ React__default.default.createElement(SodaxContext.Provider, { value: { sodax, testnet, rpcConfig } }, children);
+};
+var getSpokeTokenAddressByVault = (spokeChainId, vault) => {
+  const tokens = sdk.hubAssets[spokeChainId];
+  const address = Object.keys(tokens).find(
+    (tokenAddress) => tokens[tokenAddress].vault.toLowerCase() === vault.toLowerCase()
+  );
+  return address;
 };
 
+exports.MIGRATION_MODE_BNUSD = MIGRATION_MODE_BNUSD;
+exports.MIGRATION_MODE_ICX_SODA = MIGRATION_MODE_ICX_SODA;
 exports.SodaxProvider = SodaxProvider;
-exports.allXTokens = allXTokens;
 exports.getSpokeTokenAddressByVault = getSpokeTokenAddressByVault;
+exports.useBackendAllMoneyMarketAssets = useBackendAllMoneyMarketAssets;
+exports.useBackendAllMoneyMarketBorrowers = useBackendAllMoneyMarketBorrowers;
+exports.useBackendIntentByHash = useBackendIntentByHash;
+exports.useBackendIntentByTxHash = useBackendIntentByTxHash;
+exports.useBackendMoneyMarketAsset = useBackendMoneyMarketAsset;
+exports.useBackendMoneyMarketAssetBorrowers = useBackendMoneyMarketAssetBorrowers;
+exports.useBackendMoneyMarketAssetSuppliers = useBackendMoneyMarketAssetSuppliers;
+exports.useBackendMoneyMarketPosition = useBackendMoneyMarketPosition;
+exports.useBackendOrderbook = useBackendOrderbook;
 exports.useBorrow = useBorrow;
-exports.useCreateIntentOrder = useCreateIntentOrder;
+exports.useBridge = useBridge;
+exports.useBridgeAllowance = useBridgeAllowance;
+exports.useBridgeApprove = useBridgeApprove;
+exports.useCancelSwap = useCancelSwap;
+exports.useCancelUnstake = useCancelUnstake;
+exports.useClaim = useClaim;
+exports.useConvertedAssets = useConvertedAssets;
+exports.useDeriveUserWalletAddress = useDeriveUserWalletAddress;
+exports.useEstimateGas = useEstimateGas;
+exports.useGetBridgeableAmount = useGetBridgeableAmount;
+exports.useGetBridgeableTokens = useGetBridgeableTokens;
 exports.useHubProvider = useHubProvider;
-exports.useHubWalletAddress = useHubWalletAddress;
+exports.useInstantUnstake = useInstantUnstake;
+exports.useInstantUnstakeAllowance = useInstantUnstakeAllowance;
+exports.useInstantUnstakeApprove = useInstantUnstakeApprove;
+exports.useInstantUnstakeRatio = useInstantUnstakeRatio;
 exports.useMMAllowance = useMMAllowance;
 exports.useMMApprove = useMMApprove;
+exports.useMigrate = useMigrate;
+exports.useMigrationAllowance = useMigrationAllowance;
+exports.useMigrationApprove = useMigrationApprove;
 exports.useQuote = useQuote;
 exports.useRepay = useRepay;
+exports.useRequestTrustline = useRequestTrustline;
 exports.useReservesData = useReservesData;
 exports.useSodaxContext = useSodaxContext;
 exports.useSpokeProvider = useSpokeProvider;
+exports.useStake = useStake;
+exports.useStakeAllowance = useStakeAllowance;
+exports.useStakeApprove = useStakeApprove;
+exports.useStakeRatio = useStakeRatio;
+exports.useStakingConfig = useStakingConfig;
+exports.useStakingInfo = useStakingInfo;
 exports.useStatus = useStatus;
+exports.useStellarTrustlineCheck = useStellarTrustlineCheck;
 exports.useSupply = useSupply;
+exports.useSwap = useSwap;
 exports.useSwapAllowance = useSwapAllowance;
 exports.useSwapApprove = useSwapApprove;
+exports.useUnstake = useUnstake;
+exports.useUnstakeAllowance = useUnstakeAllowance;
+exports.useUnstakeApprove = useUnstakeApprove;
+exports.useUnstakingInfo = useUnstakingInfo;
+exports.useUnstakingInfoWithPenalty = useUnstakingInfoWithPenalty;
 exports.useUserReservesData = useUserReservesData;
 exports.useWithdraw = useWithdraw;
 //# sourceMappingURL=index.js.map