@sodax/dapp-kit 0.0.1-rc.29 → 0.0.1-rc.30

package/dist/index.js

@@ -687,6 +687,352 @@ function useGetBridgeableTokens(from, to, token) {
     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
+  });
+}
 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);
@@ -715,11 +1061,18 @@ 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.useInstantUnstake = useInstantUnstake;
+exports.useInstantUnstakeAllowance = useInstantUnstakeAllowance;
+exports.useInstantUnstakeApprove = useInstantUnstakeApprove;
+exports.useInstantUnstakeRatio = useInstantUnstakeRatio;
 exports.useMMAllowance = useMMAllowance;
 exports.useMMApprove = useMMApprove;
 exports.useQuote = useQuote;
@@ -728,12 +1081,23 @@ 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