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

package/src/hooks/swap/{useCreateIntentOrder.ts → useSwap.ts}

@@ -1,35 +1,31 @@
 import { useSodaxContext } from '../shared/useSodaxContext';
 import type {
   CreateIntentParams,
-  SpokeChainId,
-  IntentExecutionResponse,
+  SolverExecutionResponse,
   Result,
-  IntentSubmitErrorCode,
+  IntentErrorCode,
   Intent,
-  PacketData,
-  IntentSubmitError,
+  IntentError,
+  SpokeProvider,
+  IntentDeliveryInfo,
 } from '@sodax/sdk';
-import { useSpokeProvider } from '../provider/useSpokeProvider';
 import { useMutation, type UseMutationResult } from '@tanstack/react-query';
 
-type CreateIntentResult = Result<
-  [IntentExecutionResponse, Intent, PacketData],
-  IntentSubmitError<IntentSubmitErrorCode>
->;
+type CreateIntentResult = Result<[SolverExecutionResponse, Intent, IntentDeliveryInfo], IntentError<IntentErrorCode>>;
 
 /**
- * Hook for creating and submitting an intent order for cross-chain swaps.
+ * Hook for creating and submitting an swap intent order for cross-chain swaps.
  * Uses React Query's useMutation for better state management and caching.
  *
- * @param {SpokeChainId} chainId - The source chain ID where the swap will originate
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the swap
  * @returns {UseMutationResult} Mutation result object containing mutation function and state
  *
  * @example
  * ```typescript
- * const { mutateAsync: createIntent, isPending } = useCreateIntentOrder('0xa4b1.arbitrum');
+ * const { mutateAsync: swap, isPending } = useSwap(spokeProvider);
  *
  * const handleSwap = async () => {
- *   const result = await createIntent({
+ *   const result = await swap({
  *     token_src: '0x...',
  *     token_src_blockchain_id: 'arbitrum',
  *     token_dst: '0x...',
@@ -40,18 +36,20 @@ type CreateIntentResult = Result<
  * };
  * ```
  */
-export function useCreateIntentOrder(
-  chainId: SpokeChainId,
+export function useSwap(
+  spokeProvider: SpokeProvider | undefined,
 ): UseMutationResult<CreateIntentResult, Error, CreateIntentParams> {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(chainId);
 
   return useMutation<CreateIntentResult, Error, CreateIntentParams>({
     mutationFn: async (params: CreateIntentParams) => {
       if (!spokeProvider) {
         throw new Error('Spoke provider not found');
       }
-      return sodax.solver.createAndSubmitIntent(params, spokeProvider);
+      return sodax.solver.swap({
+        intentParams: params,
+        spokeProvider,
+      });
     },
   });
 }

package/src/hooks/swap/useSwapAllowance.ts

@@ -0,0 +1,47 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { CreateIntentParams, SpokeProvider } from '@sodax/sdk';
+
+/**
+ * Hook for checking token allowance for money market operations.
+ *
+ * This hook verifies if the user has approved enough tokens for a specific money market action
+ * (borrow/repay). It automatically queries and tracks the allowance status.
+ *
+ * @param {CreateIntentParams} params - The parameters for the intent to check allowance for.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for allowance checks
+ *
+ * @returns {UseQueryResult<boolean, Error>} A React Query result containing:
+ *   - data: Boolean indicating if allowance is sufficient
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during the check
+ *
+ * @example
+ * ```typescript
+ * const { data: hasAllowed, isLoading } = useMMAllowance(params, spokeProvider);
+ * ```
+ */
+export function useSwapAllowance(
+  params: CreateIntentParams | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['allowance', params],
+    queryFn: async () => {
+      if (!spokeProvider || !params) {
+        return false;
+      }
+      const allowance = await sodax.solver.isAllowanceValid({
+        intentParams: params,
+        spokeProvider,
+      });
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider && !!params,
+  });
+}

package/src/hooks/swap/useSwapApprove.ts

@@ -0,0 +1,68 @@
+import { useSodaxContext } from '../shared/useSodaxContext';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import type { CreateIntentParams, SpokeProvider } from '@sodax/sdk';
+
+interface UseApproveReturn {
+  approve: ({ params }: { params: CreateIntentParams }) => Promise<boolean>;
+  isLoading: boolean;
+  error: Error | null;
+  resetError: () => void;
+}
+
+/**
+ * Hook for approving token spending for money market actions
+ * @param token The token to approve spending for
+ * @param spokeProvider The spoke provider instance for the chain
+ * @returns Object containing approve function, loading state, error state and reset function
+ * @example
+ * ```tsx
+ * const { approve, isLoading, error } = useApprove(token, spokeProvider);
+ *
+ * // Approve tokens for supply action
+ * await approve({ amount: "100", action: "supply" });
+ * ```
+ */
+
+export function useSwapApprove(
+  params: CreateIntentParams | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseApproveReturn {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  const {
+    mutateAsync: approve,
+    isPending,
+    error,
+    reset: resetError,
+  } = useMutation({
+    mutationFn: async ({ params }: { params: CreateIntentParams | undefined }) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+      if (!params) {
+        throw new Error('Swap Params not found');
+      }
+
+      const allowance = await sodax.solver.approve({
+        intentParams: params,
+        spokeProvider,
+      });
+      if (!allowance.ok) {
+        throw new Error('Failed to approve input token');
+      }
+      return allowance.ok;
+    },
+    onSuccess: () => {
+      // Invalidate allowance query to refetch the new allowance
+      queryClient.invalidateQueries({ queryKey: ['allowance', params?.inputToken] });
+    },
+  });
+
+  return {
+    approve,
+    isLoading: isPending,
+    error: error,
+    resetError,
+  };
+}

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './hooks';
 export * from './providers';
 export * from './core';
+export * from './types';

package/src/providers/SodaxProvider.tsx

@@ -1,16 +1,33 @@
 import type { ReactNode, ReactElement } from 'react';
-import { Sodax, type SodaxConfig } from '@sodax/sdk';
+import { EvmHubProvider, getHubChainConfig, Sodax, type SodaxConfig } from '@sodax/sdk';
 import { SodaxContext } from '@/contexts';
-import React from 'react';
+import React, { useMemo } from 'react';
+import type { RpcConfig } from '@/types';
 
 interface SodaxProviderProps {
   children: ReactNode;
   testnet?: boolean;
-  config: SodaxConfig;
+  config?: SodaxConfig;
+  rpcConfig: RpcConfig;
 }
 
-export const SodaxProvider = ({ children, testnet = false, config }: SodaxProviderProps): ReactElement => {
+export const SodaxProvider = ({ children, testnet = false, config, rpcConfig }: SodaxProviderProps): ReactElement => {
   const sodax = new Sodax(config);
 
-  return <SodaxContext.Provider value={{ sodax, testnet }}>{children}</SodaxContext.Provider>;
+  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>;
 };

package/src/types.ts

@@ -0,0 +1,22 @@
+import type { StellarRpcConfig } from '@sodax/sdk';
+
+export type RpcConfig = {
+  // EVM chains - all use string RPC URLs
+  sonic?: string;
+  '0xa86a.avax'?: string;
+  '0xa4b1.arbitrum'?: string;
+  '0x2105.base'?: string;
+  '0x38.bsc'?: string;
+  '0xa.optimism'?: string;
+  '0x89.polygon'?: string;
+  nibiru?: string;
+
+  // Other chains - all use string RPC URLs
+  'injective-1'?: string;
+  sui?: string;
+  solana?: string;
+  '0x1.icon'?: string;
+
+  // Stellar - uses object with horizon and soroban RPC URLs
+  stellar?: StellarRpcConfig;
+};

package/dist/hooks/mm/useHubWalletAddress.d.ts

@@ -1,24 +0,0 @@
-import { type EvmHubProvider, type SpokeChainId } from '@sodax/sdk';
-import { type UseQueryResult } from '@tanstack/react-query';
-/**
- * Hook for retrieving the hub wallet address for a given spoke chain and address.
- *
- * This hook fetches the hub wallet address associated with a user's address on a specific spoke chain.
- * It uses the EvmWalletAbstraction to query the hub wallet address from the hub provider.
- *
- * @param spokeChainId - The chain ID of the spoke chain
- * @param address - The user's address on the spoke chain
- * @param hubProvider - The hub provider instance
- *
- * @returns {UseQueryResult<string | null>} A query result object containing:
- *   - data: The hub wallet address or null if not found
- *   - isLoading: Boolean indicating if the query is in progress
- *   - error: Error object if the query failed, null otherwise
- *
- * @example
- * ```typescript
- * const { data: hubWalletAddress, isLoading, error } = useHubWalletAddress(spokeChainId, address, hubProvider);
- * ```
- */
-export declare function useHubWalletAddress(spokeChainId: SpokeChainId, address: string | undefined, hubProvider: EvmHubProvider): UseQueryResult<string | null>;
-//# sourceMappingURL=useHubWalletAddress.d.ts.map

package/dist/hooks/mm/useHubWalletAddress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHubWalletAddress.d.ts","sourceRoot":"","sources":["../../../src/hooks/mm/useHubWalletAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAwB,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1F,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,WAAW,EAAE,cAAc,GAC1B,cAAc,CAAC,MAAM,GAAG,IAAI,CAAC,CAoB/B"}

package/dist/hooks/shared/useAllowance.d.ts

@@ -1,3 +0,0 @@
-import type { XToken } from '@sodax/types';
-export declare function useAllowance(token: XToken, amount: string): import("@tanstack/react-query").UseQueryResult<boolean, Error>;
-//# sourceMappingURL=useAllowance.d.ts.map

package/dist/hooks/shared/useAllowance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAllowance.d.ts","sourceRoot":"","sources":["../../../src/hooks/shared/useAllowance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAgB,MAAM,EAAE,MAAM,cAAc,CAAC;AAKzD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kEAwBzD"}

package/dist/hooks/shared/useApprove.d.ts

@@ -1,10 +0,0 @@
-import type { XToken } from '@sodax/types';
-interface UseApproveReturn {
-    approve: (amount: string) => Promise<boolean>;
-    isLoading: boolean;
-    error: Error | null;
-    resetError: () => void;
-}
-export declare function useApprove(token: XToken): UseApproveReturn;
-export {};
-//# sourceMappingURL=useApprove.d.ts.map

package/dist/hooks/shared/useApprove.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useApprove.d.ts","sourceRoot":"","sources":["../../../src/hooks/shared/useApprove.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAgB,MAAM,EAAE,MAAM,cAAc,CAAC;AAKzD,UAAU,gBAAgB;IACxB,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAsC1D"}

package/dist/hooks/swap/useCreateIntentOrder.d.ts

@@ -1,33 +0,0 @@
-import type { CreateIntentParams, SpokeChainId, IntentExecutionResponse, Result, IntentSubmitErrorCode, Intent, PacketData, IntentSubmitError } from '@sodax/sdk';
-import { type UseMutationResult } from '@tanstack/react-query';
-type CreateIntentResult = Result<[
-    IntentExecutionResponse,
-    Intent,
-    PacketData
-], IntentSubmitError<IntentSubmitErrorCode>>;
-/**
- * Hook for creating and submitting an intent order for cross-chain swaps.
- * Uses React Query's useMutation for better state management and caching.
- *
- * @param {SpokeChainId} chainId - The source chain ID where the swap will originate
- * @returns {UseMutationResult} Mutation result object containing mutation function and state
- *
- * @example
- * ```typescript
- * const { mutateAsync: createIntent, isPending } = useCreateIntentOrder('0xa4b1.arbitrum');
- *
- * const handleSwap = async () => {
- *   const result = await createIntent({
- *     token_src: '0x...',
- *     token_src_blockchain_id: 'arbitrum',
- *     token_dst: '0x...',
- *     token_dst_blockchain_id: 'polygon',
- *     amount: '1000000000000000000',
- *     min_output_amount: '900000000000000000'
- *   });
- * };
- * ```
- */
-export declare function useCreateIntentOrder(chainId: SpokeChainId): UseMutationResult<CreateIntentResult, Error, CreateIntentParams>;
-export {};
-//# sourceMappingURL=useCreateIntentOrder.d.ts.map

package/dist/hooks/swap/useCreateIntentOrder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useCreateIntentOrder.d.ts","sourceRoot":"","sources":["../../../src/hooks/swap/useCreateIntentOrder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,uBAAuB,EACvB,MAAM,EACN,qBAAqB,EACrB,MAAM,EACN,UAAU,EACV,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5E,KAAK,kBAAkB,GAAG,MAAM,CAC9B;IAAC,uBAAuB;IAAE,MAAM;IAAE,UAAU;CAAC,EAC7C,iBAAiB,CAAC,qBAAqB,CAAC,CACzC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,YAAY,GACpB,iBAAiB,CAAC,kBAAkB,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAYlE"}

package/src/hooks/mm/useHubWalletAddress.ts

@@ -1,49 +0,0 @@
-import { type EvmHubProvider, EvmWalletAbstraction, type SpokeChainId } from '@sodax/sdk';
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-
-/**
- * Hook for retrieving the hub wallet address for a given spoke chain and address.
- *
- * This hook fetches the hub wallet address associated with a user's address on a specific spoke chain.
- * It uses the EvmWalletAbstraction to query the hub wallet address from the hub provider.
- *
- * @param spokeChainId - The chain ID of the spoke chain
- * @param address - The user's address on the spoke chain
- * @param hubProvider - The hub provider instance
- *
- * @returns {UseQueryResult<string | null>} A query result object containing:
- *   - data: The hub wallet address or null if not found
- *   - isLoading: Boolean indicating if the query is in progress
- *   - error: Error object if the query failed, null otherwise
- *
- * @example
- * ```typescript
- * const { data: hubWalletAddress, isLoading, error } = useHubWalletAddress(spokeChainId, address, hubProvider);
- * ```
- */
-
-export function useHubWalletAddress(
-  spokeChainId: SpokeChainId,
-  address: string | undefined,
-  hubProvider: EvmHubProvider,
-): UseQueryResult<string | null> {
-  return useQuery({
-    queryKey: ['hubWallet', spokeChainId, address],
-    queryFn: async () => {
-      if (!address) return null;
-
-      try {
-        const hubWalletAddress = await EvmWalletAbstraction.getUserHubWalletAddress(
-          spokeChainId,
-          address as `0x${string}`,
-          hubProvider,
-        );
-        return hubWalletAddress;
-      } catch (error) {
-        console.log('error', error);
-        return null;
-      }
-    },
-    enabled: !!address && !!hubProvider,
-  });
-}

package/src/hooks/shared/useAllowance.ts

@@ -1,31 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import type { SpokeChainId, XToken } from '@sodax/types';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import { useSpokeProvider } from '../provider/useSpokeProvider';
-import { parseUnits } from 'viem';
-
-export function useAllowance(token: XToken, amount: string) {
-  const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(token.xChainId as SpokeChainId);
-
-  return useQuery({
-    queryKey: ['allowance', token.address, amount],
-    queryFn: async () => {
-      if (!spokeProvider) {
-        return false;
-      }
-      const allowance = await sodax.moneyMarket.isAllowanceValid(
-        {
-          token: token.address,
-          amount: parseUnits(amount, token.decimals),
-        },
-        spokeProvider,
-      );
-      if (allowance.ok) {
-        return allowance.value;
-      }
-      return false;
-    },
-    enabled: !!spokeProvider,
-  });
-}

package/src/hooks/shared/useApprove.ts

@@ -1,53 +0,0 @@
-import { useSodaxContext } from '../shared/useSodaxContext';
-import { useSpokeProvider } from '../provider/useSpokeProvider';
-import type { SpokeChainId, XToken } from '@sodax/types';
-import { parseUnits } from 'viem';
-import { useMutation, useQueryClient } from '@tanstack/react-query';
-import type { Address } from '@sodax/sdk';
-
-interface UseApproveReturn {
-  approve: (amount: string) => Promise<boolean>;
-  isLoading: boolean;
-  error: Error | null;
-  resetError: () => void;
-}
-
-export function useApprove(token: XToken): UseApproveReturn {
-  const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(token.xChainId as SpokeChainId);
-  const queryClient = useQueryClient();
-
-  const {
-    mutateAsync: approve,
-    isPending,
-    error,
-    reset: resetError,
-  } = useMutation({
-    mutationFn: async (amount: string) => {
-      if (!spokeProvider) {
-        throw new Error('Spoke provider not found');
-      }
-      const allowance = await sodax.moneyMarket.approve(
-        token.address as Address,
-        parseUnits(amount, token.decimals),
-        spokeProvider.chainConfig.addresses.assetManager as Address,
-        spokeProvider,
-      );
-      if (!allowance.ok) {
-        throw new Error('Failed to approve tokens');
-      }
-      return allowance.ok;
-    },
-    onSuccess: () => {
-      // Invalidate allowance query to refetch the new allowance
-      queryClient.invalidateQueries({ queryKey: ['allowance', token.address] });
-    },
-  });
-
-  return {
-    approve,
-    isLoading: isPending,
-    error: error as Error | null,
-    resetError,
-  };
-}