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

package/src/hooks/shared/useStellarTrustlineCheck.ts

@@ -0,0 +1,71 @@
+import { STELLAR_MAINNET_CHAIN_ID, StellarSpokeProvider, StellarSpokeService } from '@sodax/sdk';
+import type { SpokeChainId, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * React hook to check if a Stellar account has a sufficient trustline for a given token and amount.
+ *
+ * This hook queries the Stellar network (via the provided SpokeProvider) to determine
+ * whether the account has established a trustline for the specified token and if the trustline
+ * is sufficient for the intended amount. It is useful for gating UI actions that require
+ * a trustline to be present and funded.
+ *
+ * @template T - The type of SpokeProvider, defaults to SpokeProvider.
+ * @param {string | undefined} token - The Stellar asset code or token address to check the trustline for.
+ * @param {bigint | undefined} amount - The minimum amount required for the trustline.
+ * @param {T | undefined} spokeProvider - The provider instance for interacting with the Stellar network.
+ * @param {SpokeChainId | undefined} chainId - The chain ID to determine if the check should be performed (only on Stellar mainnet).
+ * @returns {UseQueryResult<boolean, Error>} A React Query result object containing:
+ *   - `data`: `true` if the trustline exists and is sufficient, `false` otherwise.
+ *   - `error`: Any error encountered during the check.
+ *   - `isLoading`: Whether the query is in progress.
+ *   - Other React Query state.
+ *
+ * @example
+ * ```tsx
+ * import { useStellarTrustlineCheck } from '@sodax/dapp-kit';
+ *
+ * const { data: hasTrustline, isLoading, error } = useStellarTrustlineCheck(
+ *   'USDC-G...TOKEN',
+ *   10000000n,
+ *   stellarProvider,
+ *   'stellar'
+ * );
+ *
+ * if (isLoading) return <span>Checking trustline...</span>;
+ * if (error) return <span>Error: {error.message}</span>;
+ * if (!hasTrustline) return <span>Trustline not established or insufficient.</span>;
+ * return <span>Trustline is sufficient!</span>;
+ * ```
+ */
+
+export function useStellarTrustlineCheck<T extends SpokeProvider = SpokeProvider>(
+  token: string | undefined,
+  amount: bigint | undefined,
+  spokeProvider: T | undefined,
+  chainId: SpokeChainId | undefined,
+): UseQueryResult<boolean, Error> {
+  return useQuery({
+    queryKey: ['stellar-trustline-check', token],
+    queryFn: async () => {
+      if (chainId !== STELLAR_MAINNET_CHAIN_ID) {
+        return true;
+      }
+      if (!spokeProvider || !token || !amount || !(spokeProvider instanceof StellarSpokeProvider)) {
+        console.error(
+          'Spoke provider, token or amount not found. Details: spokeProvider:',
+          spokeProvider,
+          'token:',
+          token,
+          'amount:',
+          amount,
+        );
+        return false;
+      }
+      const response = await StellarSpokeService.hasSufficientTrustline(token, amount, spokeProvider);
+
+      return response;
+    },
+    enabled: !!spokeProvider && !!token && !!amount,
+  });
+}

package/src/hooks/swap/useQuote.ts

@@ -1,6 +1,7 @@
 import type { SolverErrorResponse, SolverIntentQuoteRequest, SolverIntentQuoteResponse, Result } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
 
 /**
  * Hook for fetching a quote for an intent-based swap.
@@ -41,8 +42,21 @@ export const useQuote = (
   payload: SolverIntentQuoteRequest | undefined,
 ): UseQueryResult<Result<SolverIntentQuoteResponse, SolverErrorResponse> | undefined> => {
   const { sodax } = useSodaxContext();
+  
+  // Create a serializable query key by converting BigInt to string
+  const queryKey = useMemo(() => {
+    if (!payload) return ['quote', undefined];
+    return [
+      'quote',
+      {
+        ...payload,
+        amount: payload.amount.toString(),
+      },
+    ];
+  }, [payload]);
+
   return useQuery({
-    queryKey: [payload],
+    queryKey,
     queryFn: async () => {
       if (!payload) {
         return undefined;

package/src/hooks/swap/useSwap.ts

@@ -9,7 +9,7 @@ import type {
   SpokeProvider,
   IntentDeliveryInfo,
 } from '@sodax/sdk';
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import { useMutation, type UseMutationResult, useQueryClient } from '@tanstack/react-query';
 
 type CreateIntentResult = Result<[SolverExecutionResponse, Intent, IntentDeliveryInfo], IntentError<IntentErrorCode>>;
 
@@ -40,6 +40,7 @@ export function useSwap(
   spokeProvider: SpokeProvider | undefined,
 ): UseMutationResult<CreateIntentResult, Error, CreateIntentParams> {
   const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
 
   return useMutation<CreateIntentResult, Error, CreateIntentParams>({
     mutationFn: async (params: CreateIntentParams) => {
@@ -51,5 +52,9 @@ export function useSwap(
         spokeProvider,
       });
     },
+    onSuccess: () => {
+      // Invalidate balance queries to refresh both source and destination token balances
+      queryClient.invalidateQueries({ queryKey: ['xBalances'] });
+    },
   });
 }

package/src/hooks/swap/useSwapAllowance.ts

@@ -43,5 +43,6 @@ export function useSwapAllowance(
       return false;
     },
     enabled: !!spokeProvider && !!params,
+    refetchInterval: 2000,
   });
 }

package/src/hooks/swap/useSwapApprove.ts

@@ -55,7 +55,7 @@ export function useSwapApprove(
     },
     onSuccess: () => {
       // Invalidate allowance query to refetch the new allowance
-      queryClient.invalidateQueries({ queryKey: ['allowance', params?.inputToken] });
+      queryClient.invalidateQueries({ queryKey: ['allowance', params] });
     },
   });