@sodax/dapp-kit 1.5.7-beta → 2.0.0-rc.2

package/src/hooks/swap/useQuote.ts

@@ -1,62 +1,35 @@
-import type { SolverErrorResponse, SolverIntentQuoteRequest, SolverIntentQuoteResponse, Result } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import type { SolverErrorResponse, SolverIntentQuoteRequest, SolverIntentQuoteResponse } from '@sodax/sdk';
+import type { Result } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import { useMemo } from 'react';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseQuoteParams = ReadHookParams<
+  Result<SolverIntentQuoteResponse, SolverErrorResponse> | undefined,
+  { payload: SolverIntentQuoteRequest | undefined }
+>;
 
 /**
  * Hook for fetching a quote for an intent-based swap.
  *
- * This hook provides real-time quote data for an intent-based swap.
- *
- * @param {SolverIntentQuoteRequest | undefined} payload - The intent quote request parameters. If undefined, the query will be disabled.
- *
- * @returns {UseQueryResult<Result<SolverIntentQuoteResponse, SolverErrorResponse> | undefined>} A query result object containing:
- *   - data: The quote result from the solver
- *   - isLoading: Boolean indicating if the quote is being fetched
- *   - error: Error object if the quote request failed
- *   - refetch: Function to manually trigger a quote refresh
- *
  * @example
  * ```typescript
- * const { data: quote, isLoading } = useQuote({
- *   token_src: '0x...',
- *   token_src_blockchain_id: '1',
- *   token_dst: '0x...',
- *   token_dst_blockchain_id: '2',
- *   amount: '1000000000000000000',
- *   quote_type: 'exact_input',
- * });
- *
- * if (isLoading) return <div>Loading quote...</div>;
- * if (quote) {
- *   console.log('Quote received:', quote);
- * }
+ * const { data: quote, isLoading } = useQuote({ params: { payload } });
  * ```
  *
  * @remarks
  * - The quote is automatically refreshed every 3 seconds
  * - The query is disabled when payload is undefined
- * - Uses React Query for efficient caching and state management
  */
-export const useQuote = (
-  payload: SolverIntentQuoteRequest | undefined,
-): UseQueryResult<Result<SolverIntentQuoteResponse, SolverErrorResponse> | undefined> => {
+export const useQuote = ({
+  params,
+  queryOptions,
+}: UseQuoteParams = {}): 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]);
+  const payload = params?.payload;
 
   return useQuery({
-    queryKey,
+    queryKey: ['swap', 'quote', payload && { ...payload, amount: payload.amount.toString() }],
     queryFn: async () => {
       if (!payload) {
         return undefined;
@@ -65,5 +38,6 @@ export const useQuote = (
     },
     enabled: !!payload,
     refetchInterval: 3000,
+    ...queryOptions,
   });
 };

package/src/hooks/swap/useStatus.ts

@@ -1,44 +1,37 @@
-import type { Hex, SolverErrorResponse, SolverIntentStatusResponse, Result } from '@sodax/sdk';
+import type { Hex, SolverErrorResponse, SolverIntentStatusResponse } from '@sodax/sdk';
+import type { Result } from '@sodax/sdk';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseStatusParams = ReadHookParams<
+  Result<SolverIntentStatusResponse, SolverErrorResponse> | undefined,
+  { intentTxHash: Hex | undefined }
+>;
 
 /**
  * Hook for monitoring the status of an intent-based swap.
  *
- * This hook provides real-time status updates for an intent-based swap transaction.
- *
- * @param {Hex} intent_tx_hash - The transaction hash of the intent order on the hub chain
- *
- * @returns {UseQueryResult<Result<SolverIntentStatusResponse, SolverErrorResponse> | undefined>} A query result object containing:
- *   - data: The status result from the solver
- *   - isLoading: Boolean indicating if the status is being fetched
- *   - error: Error object if the status request failed
- *   - refetch: Function to manually trigger a status refresh
- *
  * @example
  * ```typescript
- * const { data: status, isLoading } = useStatus('0x...');
- *
- * if (isLoading) return <div>Loading status...</div>;
- * if (status?.ok) {
- *   console.log('Status:', status.value);
- * }
+ * const { data: status, isLoading } = useStatus({ params: { intentTxHash } });
  * ```
- *
- * @remarks
- * - The status is automatically refreshed every 3 seconds
- * - Uses React Query for efficient caching and state management
  */
-
-export const useStatus = (
-  intent_tx_hash: Hex,
-): UseQueryResult<Result<SolverIntentStatusResponse, SolverErrorResponse> | undefined> => {
+export const useStatus = ({
+  params,
+  queryOptions,
+}: UseStatusParams = {}): UseQueryResult<Result<SolverIntentStatusResponse, SolverErrorResponse> | undefined> => {
   const { sodax } = useSodaxContext();
+  const intentTxHash = params?.intentTxHash;
+
   return useQuery({
-    queryKey: [intent_tx_hash],
+    queryKey: ['swap', 'status', intentTxHash],
     queryFn: async () => {
-      return sodax.swaps.getStatus({ intent_tx_hash });
+      if (!intentTxHash) return undefined;
+      return sodax.swaps.getStatus({ intent_tx_hash: intentTxHash });
     },
-    refetchInterval: 3000, // 3s
+    enabled: !!intentTxHash,
+    refetchInterval: 3000,
+    ...queryOptions,
   });
 };

package/src/hooks/swap/useSwap.ts

@@ -1,60 +1,42 @@
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type {
-  CreateIntentParams,
-  SolverExecutionResponse,
-  Result,
-  IntentErrorCode,
-  Intent,
-  IntentError,
-  SpokeProvider,
-  IntentDeliveryInfo,
-} from '@sodax/sdk';
-import { useMutation, type UseMutationResult, useQueryClient } from '@tanstack/react-query';
+// packages/dapp-kit/src/hooks/swap/useSwap.ts
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { SpokeChainKey, SwapActionParams, SwapResponse } from '@sodax/sdk';
+import { useQueryClient } from '@tanstack/react-query';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
 
-type CreateIntentResult = Result<[SolverExecutionResponse, Intent, IntentDeliveryInfo], IntentError<IntentErrorCode>>;
+/**
+ * Mutation variables for {@link useSwap}. Generic over `K extends SpokeChainKey` (defaults to the
+ * full union). Sophisticated callers can lock K at the hook call site to narrow the
+ * `walletProvider` and `params.srcChainKey` types.
+ */
+export type UseSwapVars<K extends SpokeChainKey = SpokeChainKey> = Omit<SwapActionParams<K, false>, 'raw'>;
 
 /**
- * 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 {SpokeProvider} spokeProvider - The spoke provider to use for the swap
- * @returns {UseMutationResult} Mutation result object containing mutation function and state
+ * React hook for executing an intent-based cross-chain swap.
  *
- * @example
- * ```typescript
- * const { mutateAsync: swap, isPending } = useSwap(spokeProvider);
- *
- * const handleSwap = async () => {
- *   const result = await swap({
- *     token_src: '0x...',
- *     token_src_blockchain_id: 'arbitrum',
- *     token_dst: '0x...',
- *     token_dst_blockchain_id: 'polygon',
- *     amount: '1000000000000000000',
- *     min_output_amount: '900000000000000000'
- *   });
- * };
- * ```
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped `SwapResponse` on success.
  */
-export function useSwap(
-  spokeProvider: SpokeProvider | undefined,
-): UseMutationResult<CreateIntentResult, Error, CreateIntentParams> {
+export function useSwap<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<SwapResponse, UseSwapVars<K>> = {}): SafeUseMutationResult<
+  SwapResponse,
+  Error,
+  UseSwapVars<K>
+> {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
 
-  return useMutation<CreateIntentResult, Error, CreateIntentParams>({
-    mutationFn: async (params: CreateIntentParams) => {
-      if (!spokeProvider) {
-        throw new Error('Spoke provider not found');
-      }
-      return sodax.swaps.swap({
-        intentParams: params,
-        spokeProvider,
-      });
-    },
-    onSuccess: () => {
-      // Invalidate balance queries to refresh both source and destination token balances
-      queryClient.invalidateQueries({ queryKey: ['xBalances'] });
+  return useSafeMutation<SwapResponse, Error, UseSwapVars<K>>({
+    mutationKey: ['swap'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.swaps.swap({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ['shared', 'xBalances', vars.params.srcChainKey] });
+      queryClient.invalidateQueries({ queryKey: ['shared', 'xBalances', vars.params.dstChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
 }

package/src/hooks/swap/useSwapAllowance.ts

@@ -1,48 +1,51 @@
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { CreateIntentParams, CreateLimitOrderParams, SpokeProvider } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { CreateIntentParams, CreateLimitOrderParams } from '@sodax/sdk';
+import type { GetWalletProviderType, SpokeChainKey } from '@sodax/sdk';
+import type { ReadHookParams } from '../shared/types.js';
 
-/**
- * Hook for checking token allowance for swap operations.
- *
- * This hook verifies if the user has approved enough tokens for a specific swap action.
- * It automatically queries and tracks the allowance status.
- *
- * @param {CreateIntentParams | CreateLimitOrderParams} 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 } = useSwapAllowance(params, spokeProvider);
- * ```
- */
-export function useSwapAllowance(
-  params: CreateIntentParams | CreateLimitOrderParams | undefined,
-  spokeProvider: SpokeProvider | undefined,
-): UseQueryResult<boolean, Error> {
+export type UseSwapAllowanceParams<K extends SpokeChainKey> = ReadHookParams<
+  boolean,
+  {
+    payload: CreateIntentParams | CreateLimitOrderParams | undefined;
+    srcChainKey: K | undefined;
+    walletProvider: GetWalletProviderType<K> | undefined;
+  }
+>;
+
+export function useSwapAllowance<K extends SpokeChainKey>({
+  params,
+  queryOptions,
+}: UseSwapAllowanceParams<K> = {}): UseQueryResult<boolean, Error> {
   const { sodax } = useSodaxContext();
+  const payload = params?.payload;
+  const srcChainKey = params?.srcChainKey;
+  const walletProvider = params?.walletProvider;
 
-  return useQuery({
-    queryKey: ['allowance', params],
+  return useQuery<boolean, Error>({
+    // Extract the (chain, owner, token, amount) tuple that actually scopes the allowance —
+    // raw-object keys break per Rule 4 (bigints) and churn on every render.
+    queryKey: [
+      'swap',
+      'allowance',
+      payload?.srcChainKey,
+      payload?.srcAddress,
+      payload?.inputToken,
+      payload?.inputAmount?.toString(),
+    ],
     queryFn: async () => {
-      if (!spokeProvider || !params) {
+      if (!srcChainKey || !walletProvider || !payload) {
         return false;
       }
       const allowance = await sodax.swaps.isAllowanceValid({
-        intentParams: params,
-        spokeProvider,
+        params: payload as CreateIntentParams,
+        raw: false,
+        walletProvider,
       });
-      if (allowance.ok) {
-        return allowance.value;
-      }
-      return false;
+      return allowance.ok ? allowance.value : false;
     },
-    enabled: !!spokeProvider && !!params,
+    enabled: !!srcChainKey && !!walletProvider && !!payload,
     refetchInterval: 2000,
+    ...queryOptions,
   });
 }

package/src/hooks/swap/useSwapApprove.ts

@@ -1,68 +1,59 @@
-import { useSodaxContext } from '../shared/useSodaxContext';
-import { useMutation, useQueryClient } from '@tanstack/react-query';
-import type { CreateIntentParams, CreateLimitOrderParams, SpokeProvider } from '@sodax/sdk';
+// packages/dapp-kit/src/hooks/swap/useSwapApprove.ts
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { useQueryClient } from '@tanstack/react-query';
+import type {
+  CreateIntentParams,
+  CreateLimitOrderParams,
+  GetWalletProviderType,
+  SpokeChainKey,
+  TxReturnType,
+} from '@sodax/sdk';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
 
-interface UseApproveReturn {
-  approve: ({ params }: { params: CreateIntentParams | CreateLimitOrderParams }) => Promise<boolean>;
-  isLoading: boolean;
-  error: Error | null;
-  resetError: () => void;
-}
+/**
+ * Mutation variables for {@link useSwapApprove}. Generic over `K extends SpokeChainKey` (defaults
+ * to the full union). Sophisticated callers can lock K at the call site to narrow the
+ * `walletProvider` and `params.srcChainKey` types.
+ */
+export type UseSwapApproveVars<K extends SpokeChainKey = SpokeChainKey> = {
+  params: CreateIntentParams<K> | CreateLimitOrderParams<K>;
+  walletProvider: GetWalletProviderType<K>;
+};
 
 /**
- * Hook for approving token spending for swap actions
- * @param params The parameters for the intent 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);
+ * React hook for approving ERC-20 token spending (or trustline establishment) for a swap or
+ * limit-order intent.
  *
- * // Approve tokens for supply action
- * await approve({ amount: "100", action: "supply" });
- * ```
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped tx return value on success. Invalidates all
+ * `['swap', 'allowance', ...]` queries so any pending allowance check refreshes.
  */
-
-export function useSwapApprove(
-  params: CreateIntentParams | CreateLimitOrderParams | undefined,
-  spokeProvider: SpokeProvider | undefined,
-): UseApproveReturn {
+export function useSwapApprove<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxReturnType<K, false>, UseSwapApproveVars<K>> = {}): SafeUseMutationResult<
+  TxReturnType<K, false>,
+  Error,
+  UseSwapApproveVars<K>
+> {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
 
-  const {
-    mutateAsync: approve,
-    isPending,
-    error,
-    reset: resetError,
-  } = useMutation({
-    mutationFn: async ({ params }: { params: CreateIntentParams | CreateLimitOrderParams | undefined }) => {
-      if (!spokeProvider) {
-        throw new Error('Spoke provider not found');
-      }
-      if (!params) {
-        throw new Error('Swap Params not found');
-      }
-
-      const allowance = await sodax.swaps.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] });
+  return useSafeMutation<TxReturnType<K, false>, Error, UseSwapApproveVars<K>>({
+    mutationKey: ['swap', 'approve'],
+    ...mutationOptions,
+    mutationFn: async ({ params, walletProvider }) =>
+      unwrapResult(
+        await sodax.swaps.approve<K, false>({
+          params: params as CreateIntentParams<K>,
+          raw: false,
+          walletProvider,
+        }),
+      ),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ['swap', 'allowance'] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
-
-  return {
-    approve,
-    isLoading: isPending,
-    error: error,
-    resetError,
-  };
 }

package/src/index.ts

@@ -1,3 +1,5 @@
-export * from './hooks';
-export * from './providers';
-export * from './utils';
+export * from './hooks/index.js';
+export * from './providers/index.js';
+export * from './utils/index.js';
+
+export * from '@sodax/sdk' // export all sdk entities

package/src/providers/SodaxProvider.tsx

@@ -1,19 +1,25 @@
-import type { ReactNode, ReactElement } from 'react';
-import React from 'react';
-
+import { useMemo, useRef, type ReactNode, type ReactElement } from 'react';
 import { Sodax, type SodaxConfig } from '@sodax/sdk';
-import { SodaxContext } from '@/contexts';
-import type { RpcConfig } from '@sodax/types';
+import { SodaxContext } from '@/contexts/index.js';
+import type { DeepPartial } from '@sodax/sdk';
 
 interface SodaxProviderProps {
   children: ReactNode;
-  testnet?: boolean;
-  config?: SodaxConfig;
-  rpcConfig: RpcConfig;
+  /**
+   * Sodax config (overrides defaults including rpcUrls). **Read-once at mount** —
+   * changes after first render are ignored to prevent re-instantiating the SDK
+   * from unstable parent references. To switch config (e.g. testnet ↔ mainnet),
+   * unmount/remount the provider.
+   */
+  config?: DeepPartial<SodaxConfig>;
 }
 
-export const SodaxProvider = ({ children, testnet = false, config, rpcConfig }: SodaxProviderProps): ReactElement => {
-  const sodax = new Sodax(config);
+export const SodaxProvider = ({ children, config }: SodaxProviderProps): ReactElement => {
+  // Freeze config on first render so the SDK instance and consumers share one
+  // snapshot (matches SodaxWalletProvider semantic).
+  const configRef = useRef<DeepPartial<SodaxConfig> | undefined>(config);
+  const frozen = configRef.current;
+  const sodax = useMemo(() => new Sodax(frozen), [frozen]);
 
-  return <SodaxContext.Provider value={{ sodax, testnet, rpcConfig }}>{children}</SodaxContext.Provider>;
+  return <SodaxContext.Provider value={{ sodax }}>{children}</SodaxContext.Provider>;
 };

package/src/providers/createSodaxQueryClient.ts

@@ -0,0 +1,96 @@
+// packages/dapp-kit/src/providers/createSodaxQueryClient.ts
+import { MutationCache, QueryClient, type QueryClientConfig } from '@tanstack/react-query';
+
+export type CreateSodaxQueryClientOptions = {
+  /**
+   * Called for every mutation failure (i.e. every time `mutationFn` throws) that does NOT opt out
+   * via `meta: { silent: true }` on the mutation. Defaults to `console.error`.
+   *
+   * This is **global observability** — it runs alongside any per-hook `onError` handler the
+   * consumer set, NOT instead of them. In particular, it fires:
+   * - whether or not `mutateAsync` was awaited inside `try/catch`
+   * - whether or not `mutateAsyncSafe` was used (the wrapper packs into `Result<T>` AFTER React
+   *   Query has already entered the error state and dispatched its callbacks)
+   * - whether or not the consumer's `mutationOptions.onError` already toasted/logged
+   *
+   * It is NOT a "did this rejection escape to the global handler?" detector — accurate
+   * unhandled-rejection detection lives at `window.onunhandledrejection`, not here.
+   *
+   * To silence the default for a specific mutation that the consumer is handling locally, set
+   * `meta: { silent: true }`:
+   *
+   * ```ts
+   * useSwap({ mutationOptions: { meta: { silent: true }, onError: (e) => toast(e.message) } });
+   * ```
+   *
+   * To disable the default globally (e.g. wire your own error boundary), pass a no-op:
+   *
+   * ```ts
+   * createSodaxQueryClient({ onMutationError: () => {} });
+   * ```
+   */
+  onMutationError?: (error: unknown) => void;
+  /** Pass-through for any other QueryClient config (default queries options, etc.) */
+  config?: QueryClientConfig;
+};
+
+const defaultOnMutationError = (error: unknown): void => {
+  console.error('[sodax] Mutation error:', error);
+};
+
+/**
+ * Creates a `QueryClient` pre-wired with a mutation-error observability hook that gives dapp-kit
+ * consumers a single seam for every mutation failure across the app — wire to Sentry/Datadog/console
+ * as you like. Optional opt-in: consumers who construct their own `QueryClient` are unaffected.
+ *
+ * **Composition with a custom `MutationCache`.** If you pass `config.mutationCache`, we keep your
+ * cache instance (preserving its own `onError` / `onSuccess` / etc.) and *additionally* subscribe
+ * to its event stream to dispatch `onMutationError`. Both your handler and the dapp-kit handler
+ * fire — neither replaces the other. If you don't pass one, we install our own.
+ *
+ * @example default — logs to console
+ * const queryClient = createSodaxQueryClient();
+ *
+ * @example custom — Sentry
+ * const queryClient = createSodaxQueryClient({
+ *   onMutationError: (e) => Sentry.captureException(e),
+ * });
+ *
+ * @example silent — disable the default
+ * const queryClient = createSodaxQueryClient({ onMutationError: () => {} });
+ *
+ * @example bring-your-own MutationCache
+ * const myCache = new MutationCache({ onError: myOwnErrorHandler });
+ * const queryClient = createSodaxQueryClient({ config: { mutationCache: myCache } });
+ * // myOwnErrorHandler still runs; onMutationError ALSO runs (unless meta.silent).
+ */
+export function createSodaxQueryClient({
+  onMutationError = defaultOnMutationError,
+  config,
+}: CreateSodaxQueryClientOptions = {}): QueryClient {
+  if (config?.mutationCache) {
+    // Compose: keep the consumer's cache, attach our observability as an extra subscriber.
+    // The consumer's own `MutationCache.onError` (if any) still fires — subscribe is additive.
+    config.mutationCache.subscribe(event => {
+      if (
+        event.type === 'updated' &&
+        event.action.type === 'error' &&
+        event.mutation.options.meta?.silent !== true
+      ) {
+        onMutationError(event.action.error);
+      }
+    });
+    return new QueryClient(config);
+  }
+
+  // No consumer cache: install our own with `onError` directly (cheaper than a subscribe loop).
+  return new QueryClient({
+    ...config,
+    mutationCache: new MutationCache({
+      onError: (error, _vars, _ctx, mutation) => {
+        if (mutation.options.meta?.silent === true) return;
+        onMutationError(error);
+      },
+    }),
+  });
+}

package/src/providers/index.ts

@@ -1 +1,2 @@
-export { SodaxProvider } from './SodaxProvider';
+export { SodaxProvider } from './SodaxProvider.js';
+export { createSodaxQueryClient, type CreateSodaxQueryClientOptions } from './createSodaxQueryClient.js';