@sodax/dapp-kit 0.0.1-rc.21 → 0.0.1-rc.23

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import React, { createContext, useContext, useMemo } from 'react';
-import { SpokeService, spokeChainConfig, SONIC_MAINNET_CHAIN_ID, SonicSpokeProvider, EvmSpokeProvider, SuiSpokeProvider, IconSpokeProvider, InjectiveSpokeProvider, StellarSpokeProvider, SolanaSpokeProvider, Sodax, getHubChainConfig, EvmHubProvider, hubAssets } from '@sodax/sdk';
+import { SpokeService, deriveUserWalletAddress, spokeChainConfig, SONIC_MAINNET_CHAIN_ID, SonicSpokeProvider, EvmSpokeProvider, SuiSpokeProvider, IconSpokeProvider, InjectiveSpokeProvider, StellarSpokeProvider, SolanaSpokeProvider, Sodax, hubAssets } from '@sodax/sdk';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { parseUnits } from 'viem';
 
@@ -23,11 +23,26 @@ function useEstimateGas(spokeProvider) {
     }
   });
 }
+function useDeriveUserWalletAddress(spokeProvider, walletAddress) {
+  const { sodax } = useSodaxContext();
+  return useQuery({
+    queryKey: ["deriveUserWalletAddress", spokeProvider?.chainConfig.chain.id, walletAddress],
+    queryFn: async () => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider is required");
+      }
+      return await deriveUserWalletAddress(spokeProvider, sodax.hubProvider, walletAddress);
+    },
+    enabled: !!spokeProvider,
+    refetchInterval: false
+    // This is a deterministic operation, no need to refetch
+  });
+}
 
 // src/hooks/provider/useHubProvider.ts
 function useHubProvider() {
-  const { hubProvider } = useSodaxContext();
-  return hubProvider;
+  const { sodax } = useSodaxContext();
+  return sodax.hubProvider;
 }
 function useSpokeProvider(spokeChainId, walletProvider) {
   const { rpcConfig } = useSodaxContext();
@@ -69,10 +84,14 @@ function useSpokeProvider(spokeChainId, walletProvider) {
     }
     if (xChainType === "STELLAR") {
       const stellarConfig = spokeChainConfig[spokeChainId];
-      return new StellarSpokeProvider(walletProvider, stellarConfig, {
-        horizonRpcUrl: stellarConfig.horizonRpcUrl,
-        sorobanRpcUrl: stellarConfig.sorobanRpcUrl
-      });
+      return new StellarSpokeProvider(
+        walletProvider,
+        stellarConfig,
+        rpcConfig.stellar ? rpcConfig.stellar : {
+          horizonRpcUrl: stellarConfig.horizonRpcUrl,
+          sorobanRpcUrl: stellarConfig.sorobanRpcUrl
+        }
+      );
     }
     if (xChainType === "SOLANA") {
       return new SolanaSpokeProvider(
@@ -368,21 +387,246 @@ function useCancelSwap(spokeProvider) {
     }
   });
 }
-var SodaxProvider = ({ children, testnet = false, config, rpcConfig }) => {
-  const sodax = new Sodax(config);
-  const hubChainId = config?.hubProviderConfig?.chainConfig.chain.id;
-  const hubRpcUrl = config?.hubProviderConfig?.hubRpcUrl;
-  const hubProvider = useMemo(() => {
-    if (hubChainId && hubRpcUrl) {
-      const hubChainCfg = getHubChainConfig(hubChainId);
-      return new EvmHubProvider({
-        hubRpcUrl,
-        chainConfig: hubChainCfg
+var useBackendIntentByTxHash = (txHash) => {
+  const { sodax } = useSodaxContext();
+  return useQuery({
+    queryKey: ["backend", "intent", "txHash", txHash],
+    queryFn: async () => {
+      if (!txHash) {
+        return void 0;
+      }
+      return sodax.backendApiService.getIntentByTxHash(txHash);
+    },
+    enabled: !!txHash && txHash.length > 0,
+    retry: 3
+  });
+};
+var useBackendIntentByHash = (intentHash) => {
+  const { sodax } = useSodaxContext();
+  return useQuery({
+    queryKey: ["backend", "intent", "hash", intentHash],
+    queryFn: async () => {
+      if (!intentHash) {
+        return void 0;
+      }
+      return sodax.backendApiService.getIntentByHash(intentHash);
+    },
+    enabled: !!intentHash && intentHash.length > 0,
+    retry: 3
+  });
+};
+var useBackendOrderbook = (params) => {
+  const { sodax } = useSodaxContext();
+  return useQuery({
+    queryKey: ["backend", "solver", "orderbook", params],
+    queryFn: async () => {
+      if (!params || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApiService.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 useQuery({
+    queryKey: ["backend", "moneymarket", "position", userAddress],
+    queryFn: async () => {
+      if (!userAddress) {
+        return void 0;
+      }
+      return sodax.backendApiService.getMoneyMarketPosition(userAddress);
+    },
+    enabled: !!userAddress && userAddress.length > 0,
+    retry: 3
+  });
+};
+var useBackendAllMoneyMarketAssets = () => {
+  const { sodax } = useSodaxContext();
+  return useQuery({
+    queryKey: ["backend", "moneymarket", "assets", "all"],
+    queryFn: async () => {
+      return sodax.backendApiService.getAllMoneyMarketAssets();
+    },
+    retry: 3
+  });
+};
+var useBackendMoneyMarketAsset = (reserveAddress) => {
+  const { sodax } = useSodaxContext();
+  return useQuery({
+    queryKey: ["backend", "moneymarket", "asset", reserveAddress],
+    queryFn: async () => {
+      if (!reserveAddress) {
+        return void 0;
+      }
+      return sodax.backendApiService.getMoneyMarketAsset(reserveAddress);
+    },
+    enabled: !!reserveAddress && reserveAddress.length > 0,
+    retry: 3
+  });
+};
+var useBackendMoneyMarketAssetBorrowers = (params) => {
+  const { sodax } = useSodaxContext();
+  return useQuery({
+    queryKey: ["backend", "moneymarket", "asset", "borrowers", params],
+    queryFn: async () => {
+      if (!params.reserveAddress || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApiService.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 useQuery({
+    queryKey: ["backend", "moneymarket", "asset", "suppliers", params],
+    queryFn: async () => {
+      if (!params.reserveAddress || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApiService.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 useQuery({
+    queryKey: ["backend", "moneymarket", "borrowers", "all", params],
+    queryFn: async () => {
+      if (!params || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApiService.getAllMoneyMarketBorrowers(params);
+    },
+    enabled: !!params && !!params.offset && !!params.limit,
+    retry: 3
+  });
+};
+function useBridgeAllowance(params, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return 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 = useQueryClient();
+  const {
+    mutateAsync: approve,
+    isPending,
+    error,
+    reset: resetError
+  } = 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.createElement(SodaxContext.Provider, { value: { sodax, testnet, hubProvider, rpcConfig } }, children);
+  });
+  return {
+    approve,
+    isLoading: isPending,
+    error,
+    resetError
+  };
+}
+function useBridge(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return 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 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 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
+  });
+}
+var SodaxProvider = ({ children, testnet = false, config, rpcConfig }) => {
+  const sodax = new Sodax(config);
+  return /* @__PURE__ */ React.createElement(SodaxContext.Provider, { value: { sodax, testnet, rpcConfig } }, children);
 };
 var getSpokeTokenAddressByVault = (spokeChainId, vault) => {
   const tokens = hubAssets[spokeChainId];
@@ -392,6 +636,6 @@ var getSpokeTokenAddressByVault = (spokeChainId, vault) => {
   return address;
 };
 
-export { SodaxProvider, getSpokeTokenAddressByVault, useBorrow, useCancelSwap, useEstimateGas, useHubProvider, useMMAllowance, useMMApprove, useQuote, useRepay, useReservesData, useSodaxContext, useSpokeProvider, useStatus, useSupply, useSwap, useSwapAllowance, useSwapApprove, useUserReservesData, useWithdraw };
+export { SodaxProvider, getSpokeTokenAddressByVault, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelSwap, useDeriveUserWalletAddress, useEstimateGas, useGetBridgeableAmount, useGetBridgeableTokens, useHubProvider, useMMAllowance, useMMApprove, useQuote, useRepay, useReservesData, useSodaxContext, useSpokeProvider, useStatus, useSupply, useSwap, useSwapAllowance, useSwapApprove, useUserReservesData, useWithdraw };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map