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

package/src/hooks/bridge/useGetBridgeableTokens.ts

@@ -0,0 +1,62 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { XToken, SpokeChainId } from '@sodax/sdk';
+import { useSodaxContext } from '../shared';
+
+/**
+/**
+ * Hook for retrieving all bridgeable tokens from a source token on one chain to a destination chain.
+ *
+ * This hook queries and tracks the set of tokens on the destination chain that can be bridged to,
+ * given a source chain, destination chain, and source token address.
+ *
+ * @param {SpokeChainId | undefined} from - The source chain ID
+ * @param {SpokeChainId | undefined} to - The destination chain ID
+ * @param {string | undefined} token - The source token address
+ *
+ * @returns {UseQueryResult<XToken[], Error>} A React Query result containing:
+ *   - data: Array of bridgeable tokens (XToken[]) on the destination chain
+ *   - error: Any error that occurred during the query
+ *
+ *
+ * @example
+ * ```typescript
+ * const { data: bridgeableTokens, isLoading } = useGetBridgeableTokens(
+ *   fromChainId,
+ *   toChainId,
+ *   fromTokenAddress
+ * );
+ *
+ * if (bridgeableTokens && bridgeableTokens.length > 0) {
+ *   bridgeableTokens.forEach(token => {
+ *     console.log(`Bridgeable token: ${token.symbol} (${token.address}) on chain ${token.xChainId}`);
+ *   });
+ * } else {
+ *   console.log('No bridgeable tokens found for the selected route.');
+ * }
+ * ```
+ */
+export function useGetBridgeableTokens(
+  from: SpokeChainId | undefined,
+  to: SpokeChainId | undefined,
+  token: string | undefined,
+): UseQueryResult<XToken[], Error> {
+  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,
+  });
+}

package/src/hooks/index.ts

@@ -2,3 +2,5 @@ export * from './shared';
 export * from './provider';
 export * from './mm';
 export * from './swap';
+export * from './backend';
+export * from './bridge';

package/src/hooks/mm/useUserFormattedSummary.ts

@@ -1,4 +1,4 @@
-import { type FormatUserSummaryResponse, type FormatReserveUSDResponse, SpokeProvider } from '@sodax/sdk';
+import type { FormatUserSummaryResponse, FormatReserveUSDResponse, SpokeProvider } from '@sodax/sdk';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
 

package/src/hooks/mm/useUserReservesData.ts

@@ -1,4 +1,4 @@
-import { SpokeProvider, type UserReserveData } from '@sodax/sdk';
+import type { SpokeProvider, UserReserveData } from '@sodax/sdk';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
 

package/src/hooks/provider/useHubProvider.ts

@@ -1,8 +1,8 @@
 import type { EvmHubProvider } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
-export function useHubProvider(): EvmHubProvider | undefined {
-  const { hubProvider } = useSodaxContext();
+export function useHubProvider(): EvmHubProvider {
+  const { sodax } = useSodaxContext();
 
-  return hubProvider;
+  return sodax.hubProvider;
 }

package/src/hooks/provider/useSpokeProvider.ts

@@ -93,10 +93,16 @@ export function useSpokeProvider(
 
     if (xChainType === 'STELLAR') {
       const stellarConfig = spokeChainConfig[spokeChainId] as StellarSpokeChainConfig;
-      return new StellarSpokeProvider(walletProvider as IStellarWalletProvider, stellarConfig, {
-        horizonRpcUrl: stellarConfig.horizonRpcUrl,
-        sorobanRpcUrl: stellarConfig.sorobanRpcUrl,
-      });
+      return new StellarSpokeProvider(
+        walletProvider as IStellarWalletProvider,
+        stellarConfig,
+        rpcConfig.stellar
+          ? rpcConfig.stellar
+          : {
+              horizonRpcUrl: stellarConfig.horizonRpcUrl,
+              sorobanRpcUrl: stellarConfig.sorobanRpcUrl,
+            },
+      );
     }
 
     if (xChainType === 'SOLANA') {

package/src/hooks/shared/index.ts

@@ -1,2 +1,3 @@
 export * from './useSodaxContext';
 export * from './useEstimateGas';
+export * from './useDeriveUserWalletAddress';

package/src/hooks/shared/useDeriveUserWalletAddress.ts

@@ -0,0 +1,44 @@
+// packages/dapp-kit/src/hooks/shared/useDeriveUserWalletAddress.ts
+import { deriveUserWalletAddress, type SpokeProvider, type EvmHubProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from './useSodaxContext';
+import type { Address } from 'viem';
+
+/**
+ * Hook for deriving user wallet address for hub abstraction.
+ *
+ * This hook derives the user's abstracted wallet address for the hub chain.
+ * If the spoke chain is the same as the hub chain, it returns the original wallet address.
+ * Otherwise, it returns the abstracted wallet address for cross-chain operations.
+ *
+ * @param spokeProvider - The spoke provider instance for the origin chain
+ * @param walletAddress - Optional user wallet address on spoke chain. If not provided, will fetch from spokeProvider
+ * @returns A React Query result object containing:
+ *   - data: The derived user wallet address when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during derivation
+ *
+ * @example
+ * ```typescript
+ * const { data: derivedAddress, isLoading, error } = useDeriveUserWalletAddress(spokeProvider, userAddress);
+ * ```
+ */
+export function useDeriveUserWalletAddress(
+  spokeProvider: SpokeProvider | undefined,
+  walletAddress?: string | undefined,
+): UseQueryResult<Address, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['deriveUserWalletAddress', spokeProvider?.chainConfig.chain.id, walletAddress],
+    queryFn: async (): Promise<Address> => {
+      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
+  });
+}

package/src/providers/SodaxProvider.tsx

@@ -1,7 +1,8 @@
 import type { ReactNode, ReactElement } from 'react';
-import { EvmHubProvider, getHubChainConfig, Sodax, type SodaxConfig } from '@sodax/sdk';
+import React from 'react';
+
+import { Sodax, type SodaxConfig } from '@sodax/sdk';
 import { SodaxContext } from '@/contexts';
-import React, { useMemo } from 'react';
 import type { RpcConfig } from '@/types';
 
 interface SodaxProviderProps {
@@ -14,20 +15,5 @@ interface SodaxProviderProps {
 export const SodaxProvider = ({ children, testnet = false, config, rpcConfig }: SodaxProviderProps): ReactElement => {
   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: hubRpcUrl,
-        chainConfig: hubChainCfg,
-      });
-    }
-    return undefined;
-  }, [hubChainId, hubRpcUrl]);
-
-  return <SodaxContext.Provider value={{ sodax, testnet, hubProvider, rpcConfig }}>{children}</SodaxContext.Provider>;
+  return <SodaxContext.Provider value={{ sodax, testnet, rpcConfig }}>{children}</SodaxContext.Provider>;
 };