@sodax/dapp-kit 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/index.d.ts

@@ -1,9 +1,36 @@
-import { UseQueryOptions, UseMutationOptions, UseMutationResult, MutateOptions, UseQueryResult, QueryClientConfig, QueryClient } from '@tanstack/react-query';
-import { Result, Sodax, SpokeChainKey, GetEstimateGasReturnType, EstimateGasParams, IStellarWalletProvider, StellarChainKey, IXServiceBase, XToken, EvmHubProvider, IBitcoinWalletProvider, RadfiWalletBalance, RadfiUtxo, MoneyMarketBorrowActionParams, TxHashPair, MoneyMarketRepayActionParams, MoneyMarketSupplyActionParams, MoneyMarketWithdrawActionParams, UserReserveData, AggregatedReserveData, BaseCurrencyInfo, ReservesDataHumanized, Address as Address$1, MoneyMarketParams, MoneyMarketApproveActionParams, TxReturnType, Erc20Token, ChainKey, ReserveDataHumanized, FormatReserveUSDResponse, FormatUserSummaryResponse, SolverIntentQuoteResponse, SolverErrorResponse, SolverIntentQuoteRequest, SwapActionParams, SwapResponse, SolverIntentStatusResponse, Hex, CreateIntentParams, CreateLimitOrderParams, GetWalletProviderType, Intent, LimitOrderActionParams, IntentResponse, UserIntentsResponse, SubmitSwapTxResponse, SubmitSwapTxRequest, RequestOverrideConfig, SubmitSwapTxStatusResponse, OrderbookResponse, MoneyMarketPosition, MoneyMarketAsset, MoneyMarketAssetBorrowers, MoneyMarketAssetSuppliers, MoneyMarketBorrowers, BridgeParams, CreateBridgeIntentParams, BridgeLimit, StakeAction, StakeParams, UnstakeAction, ClaimAction, CancelUnstakeAction, StakingInfo, UnstakingInfo, UnstakeRequestWithPenalty, StakingConfig, InstantUnstakeAction, UnstakeParams, InstantUnstakeParams, PartnerFeeClaimAssetBalance, AutoSwapPreferences, FeeTokenApproveParams, FeeTokenApproveAction, HubChainKey, SetSwapPreferenceAction, PartnerFeeClaimSwapAction, IntentAutoSwapResult, HubAssetBalance, WithdrawHubAssetAction, IcxMigrateAction, IcxRevertMigrationAction, UnifiedBnUSDMigrateAction, BalnMigrateAction, MigrationAction, IcxMigrateParams, IcxCreateRevertMigrationParams, UnifiedBnUSDMigrateParams, BalnMigrateParams, PoolKey, PoolData, ClPositionInfo, AssetDepositAction, AssetWithdrawAction, CreateAssetDepositParams, ClSupplyParams, ClIncreaseLiquidityParams, ClLiquidityDecreaseLiquidityAction, ClDecreaseLiquidityParams, CreateAssetWithdrawParams, PoolSpokeAssets, DestinationParamsType, ClLiquidityClaimRewardsAction, DeepPartial, SodaxConfig } from '@sodax/sdk';
+import { UseMutationOptions, UseQueryOptions, UseMutationResult, MutateOptions, UseQueryResult, QueryClientConfig, QueryClient } from '@tanstack/react-query';
+import { Result, Sodax, SpokeChainKey, GetEstimateGasReturnType, EstimateGasParams, IStellarWalletProvider, StellarChainKey, INearWalletProvider, GetWalletProviderType, IXServiceBase, XToken, EvmHubProvider, IBitcoinWalletProvider, RadfiWalletBalance, IWalletProvider, RadfiUtxo, MoneyMarketBorrowActionParams, TxHashPair, MoneyMarketRepayActionParams, MoneyMarketSupplyActionParams, MoneyMarketWithdrawActionParams, UserReserveData, AggregatedReserveData, BaseCurrencyInfo, ReservesDataHumanized, Address as Address$1, MoneyMarketParams, MoneyMarketApproveActionParams, TxReturnType, Erc20Token, ChainKey, ReserveDataHumanized, FormatReserveUSDResponse, FormatUserSummaryResponse, SolverIntentQuoteResponse, SolverErrorResponse, SolverIntentQuoteRequest, SwapActionParams, SwapResponse, SolverIntentStatusResponse, Hex, CreateIntentParams, CreateLimitOrderParams, Intent, LimitOrderActionParams, IntentResponse, UserIntentsResponse, OrderbookResponse, MoneyMarketPosition, MoneyMarketAsset, MoneyMarketAssetBorrowers, MoneyMarketAssetSuppliers, MoneyMarketBorrowers, GetSwapTokensResponseV2, RequestOverrideConfig, GetSwapTokensByChainResponseV2, QuoteResponseV2, QuoteRequestV2, QuoteQueryV2, DeadlineResponseV2, DeadlineQueryV2, AllowanceCheckResponseV2, CreateIntentParamsV2, ApproveResponseV2, CreateIntentResponseV2, SubmitIntentRequestV2, SubmitIntentResponseV2, StatusResponseV2, SwapIntentStatusCodeV2, CancelIntentRequestV2, CancelIntentResponseV2, IntentHashResponseV2, IntentRequestV2, IntentPacketResponseV2, IntentPacketRequestV2, IntentExtraDataResponseV2, IntentExtraDataRequestV2, IntentStateV2, GetIntentResponseV2, CreateLimitOrderParamsV2, CreateLimitOrderResponseV2, GasEstimateResponseV2, GasEstimateRequestV2, FeeResponseV2, SubmitTxRequestV2, SubmitTxResponseV2, SubmitTxStatusResponseV2, BridgeParams, CreateBridgeIntentParams, BridgeLimit, StakeAction, StakeParams, UnstakeAction, ClaimAction, CancelUnstakeAction, StakingInfo, UnstakingInfo, UnstakeRequestWithPenalty, StakingConfig, InstantUnstakeAction, UnstakeParams, InstantUnstakeParams, PartnerFeeClaimAssetBalance, AutoSwapPreferences, FeeTokenApproveParams, FeeTokenApproveAction, HubChainKey, SetSwapPreferenceAction, PartnerFeeClaimSwapAction, IntentAutoSwapResult, PartnerFeeClaimCancelAction, GetUserIntentParams, HubAssetBalance, WithdrawHubAssetAction, IcxMigrateAction, IcxRevertMigrationAction, UnifiedBnUSDMigrateAction, BalnMigrateAction, MigrationAction, IcxMigrateParams, IcxCreateRevertMigrationParams, UnifiedBnUSDMigrateParams, BalnMigrateParams, PoolKey, PoolData, ClPositionInfo, AssetDepositAction, AssetWithdrawAction, CreateAssetDepositParams, ClSupplyParams, ClIncreaseLiquidityParams, ClLiquidityDecreaseLiquidityAction, ClDecreaseLiquidityParams, CreateAssetWithdrawParams, PoolSpokeAssets, DestinationParamsType, ClLiquidityClaimRewardsAction, LeverageYieldEffectiveApr, LeverageYieldPosition, LeverageYieldSwapDepositParams, LeverageYieldSwapPayload, SolverExecutionRequest, SolverExecutionResponse, VaultSwapActionParams, VaultSwapResponse, LeverageYieldSwapWithdrawParams, SodaxOptions } from '@sodax/sdk';
 export * from '@sodax/sdk';
 import { Address } from 'viem';
 import { ReactNode, ReactElement } from 'react';
 
+/**
+ * Predicate for the canonical "user cancelled the wallet prompt" outcome.
+ *
+ * The SDK classifies wallet rejection at the source: `intentCreationFailed` / `approveFailed`
+ * wrappers emit `SodaxError<'USER_REJECTED'>` whenever the underlying cause matches a known
+ * rejection shape (viem `4001` / `UserRejectedRequestError`, ICON Hana `CANCEL_SIGNING`,
+ * Solana / Sui / Stellar / Stacks / NEAR / Injective name + message patterns). Consumers
+ * branch on this code to render a "Cancelled" UI instead of a "Failed" toast — user
+ * cancellation is a normal flow, not a failure.
+ *
+ * Use after `mutateAsyncSafe` (or inside an `onError` / `catch`):
+ *
+ * ```ts
+ * const result = await swap.mutateAsyncSafe({ params, walletProvider });
+ * if (!result.ok) {
+ *   if (isUserRejectedError(result.error)) return;            // silent — user cancelled
+ *   toast.error(getErrorMessage(result.error));                // real failure
+ * }
+ * ```
+ *
+ * The check trusts the SDK's classification — it does NOT re-scan message content. Errors
+ * raised outside the SDK boundary (e.g. a non-SodaxError thrown from a `queryFn`) will not
+ * match, which is intentional: only the SDK's `USER_REJECTED` is the canonical "cancelled"
+ * signal.
+ */
+declare function isUserRejectedError(error: unknown): boolean;
+
 /**
  * Subset of `UseQueryOptions` consumers may override on dapp-kit read hooks.
  *
@@ -151,6 +178,72 @@ declare function useRequestTrustline(token: string | undefined): {
     data: string | null;
 };
 
+type UseNearStorageCheckParams = ReadHookParams<boolean, {
+    token: string | undefined;
+    accountId: string | undefined;
+    chainId: SpokeChainKey | undefined;
+}>;
+/**
+ * Whether `accountId` is NEP-141 storage-registered for `token` on NEAR — the receive-side
+ * prerequisite for any leg that delivers a token to the user on NEAR (swap output on NEAR, bridge
+ * into NEAR, money-market borrow/withdraw to NEAR). NEAR's analogue of a Stellar trustline.
+ *
+ * Returns `true` (no gate) when `chainId` is not NEAR, mirroring how the Stellar trustline check
+ * short-circuits off-chain. Native NEAR is not a NEP-141 token, so the SDK reports it as registered.
+ *
+ * Pair with {@link useRegisterNearStorage} to perform the one-time `storage_deposit` when this
+ * resolves to `false`.
+ */
+declare function useNearStorageCheck({ params, queryOptions, }?: UseNearStorageCheckParams): UseQueryResult<boolean, Error>;
+
+type UseRegisterNearStorageVars = {
+    token: string;
+    accountId: string;
+    walletProvider: INearWalletProvider;
+    /** Storage bond override; defaults to the SDK's `NEAR_STORAGE_DEPOSIT` (0.00125 NEAR). */
+    deposit?: bigint;
+};
+/**
+ * Submit a NEP-141 `storage_deposit` so `accountId` can receive `token` on NEAR. NEAR's analogue of
+ * requesting a Stellar trustline; pair with {@link useNearStorageCheck} and call this when the check
+ * resolves to `false`. The recipient's NEAR wallet signs the registration tx.
+ *
+ * Pure mutation: pass `{ token, accountId, walletProvider }` to `mutate(...)`. The hook itself only
+ * takes the structural `mutationOptions` slot. `registerStorage` throws natively (no `Result<T>`),
+ * so this hook is registered as `nativeThrow` in the mutation contract. On success it invalidates
+ * the matching {@link useNearStorageCheck} query.
+ */
+declare function useRegisterNearStorage({ mutationOptions, }?: MutationHookParams<string, UseRegisterNearStorageVars>): SafeUseMutationResult<string, Error, UseRegisterNearStorageVars>;
+
+interface UseNearStorageGateParams {
+    /** Destination chain the token is delivered on. */
+    dstChainKey: SpokeChainKey;
+    /** Destination token address the recipient must be registered for. */
+    token: string | undefined;
+    /** Recipient NEAR account id. */
+    accountId: string | undefined;
+    /** Destination wallet provider; only consumed when it is the NEAR provider. */
+    walletProvider: GetWalletProviderType<SpokeChainKey> | undefined;
+}
+interface NearStorageGate {
+    /** Destination is NEAR. */
+    isNear: boolean;
+    /** Destination is NEAR and the recipient is not yet storage-registered for `token`. */
+    needsRegistration: boolean;
+    /** The downstream action must stay disabled while the gate is unresolved or unmet. */
+    blocksAction: boolean;
+    /** The registration-status query is actively fetching. */
+    isChecking: boolean;
+    /** A `storage_deposit` tx is in flight. */
+    isRegistering: boolean;
+    /** Submit the `storage_deposit`; resolves to the SDK `Result` or `undefined` if inputs are missing. */
+    registerStorage: () => Promise<Result<string> | undefined>;
+}
+/**
+ * NEP-141 storage-registration gate for flows that deliver a token to a user on NEAR.
+ */
+declare function useNearStorageGate({ dstChainKey, token, accountId, walletProvider, }: UseNearStorageGateParams): NearStorageGate;
+
 type UseGetUserHubWalletAddressParams = ReadHookParams<Address, {
     spokeChainId?: SpokeChainKey;
     spokeAddress?: string;
@@ -191,7 +284,7 @@ type UseXBalancesParams = ReadHookParams<Record<string, bigint>, XBalancesInputs
  * tests and for advanced callers that compose their own `useQuery` wrapper.
  */
 declare function getXBalancesQueryOptions({ xService, xChainId, xTokens, address }: XBalancesInputs): {
-    queryKey: readonly ["shared", "xBalances", "0xa86a.avax" | "0xa4b1.arbitrum" | "0x2105.base" | "0x38.bsc" | "injective-1" | "sonic" | "0x1.icon" | "sui" | "0xa.optimism" | "0x89.polygon" | "solana" | "stellar" | "hyper" | "lightlink" | "near" | "ethereum" | "bitcoin" | "redbelly" | "0x2019.kaia" | "stacks" | undefined, (readonly [string, string])[], string | undefined];
+    queryKey: readonly ["shared", "xBalances", "0xa86a.avax" | "0xa4b1.arbitrum" | "0x2105.base" | "0x38.bsc" | "injective-1" | "sonic" | "0x1.icon" | "sui" | "0xa.optimism" | "0x89.polygon" | "solana" | "stellar" | "hyper" | "lightlink" | "near" | "ethereum" | "bitcoin" | "redbelly" | "0x2019.kaia" | "stacks" | "hedera" | undefined, (readonly [string, string])[], string | undefined];
     queryFn: () => Promise<Record<string, bigint>>;
     enabled: boolean;
     refetchInterval: number;
@@ -228,12 +321,32 @@ declare function saveRadfiSession(address: string, session: RadfiSession): void;
 declare function loadRadfiSession(address: string): RadfiSession | null;
 declare function clearRadfiSession(address: string): void;
 /**
- * React hook for authenticating with Radfi via BIP322-signed message. Pure mutation: pass
+ * React hook for authenticating with Bound Exchange via BIP322-signed message. Pure mutation: pass
  * `{ walletProvider }` to `mutate({...})`. The hook itself takes no arguments other than the
  * structural `mutationOptions` slot.
  */
 declare function useRadfiAuth({ mutationOptions, }?: MutationHookParams<RadfiAuthResult, UseRadfiAuthVars>): SafeUseMutationResult<RadfiAuthResult, Error, UseRadfiAuthVars>;
 
+type UseEnsureRadfiAccessTokenVars = {
+    walletProvider: IBitcoinWalletProvider;
+};
+/**
+ * Ensure a valid Bound Exchange access token and return it. Refreshes the existing token (no
+ * signature prompt) when a refresh token is available, falling back to a full BIP322 re-auth only if
+ * refresh fails. Bound tokens are short-lived, so call this right before a Bitcoin-source
+ * createIntent — forward the returned token via the typed `extras.bound.accessToken` slot (SDK in-process)
+ * or the `accessToken` body field on the backend DTO — or before the client-side sign + co-sign step.
+ *
+ * @example
+ * const { mutateAsync: ensureToken } = useEnsureRadfiAccessToken();
+ * const accessToken = await ensureToken({ walletProvider });
+ * // SDK in-process (Bitcoin-gated extras):
+ * await sodax.swaps.createIntent({ params, extras: { bound: { accessToken } }, raw: true });
+ * // or backend createIntent — token in the body, not an x-bound-access-token header:
+ * await createIntent({ body: { ...body, accessToken } });
+ */
+declare function useEnsureRadfiAccessToken({ mutationOptions, }?: MutationHookParams<string, UseEnsureRadfiAccessTokenVars>): SafeUseMutationResult<string, Error, UseEnsureRadfiAccessTokenVars>;
+
 type UseRadfiSessionReturn = {
     walletAddress: string | undefined;
     isAuthed: boolean;
@@ -248,7 +361,7 @@ type UseFundTradingWalletVars = {
     walletProvider: IBitcoinWalletProvider;
 };
 /**
- * React hook for funding the user's Radfi trading wallet from their personal Bitcoin wallet.
+ * React hook for funding the user's Bound Exchange trading wallet from their personal Bitcoin wallet.
  * Pure mutation: pass `{ amount, walletProvider }` to `mutate({...})`. Returns the broadcast tx
  * id on success.
  */
@@ -271,7 +384,7 @@ type UseTradingWalletReturn = {
     tradingAddress: string | undefined;
 };
 /**
- * Returns the Radfi trading wallet address from the persisted session.
+ * Returns the Bound Exchange trading wallet address from the persisted session.
  * Trading wallet is created automatically during authentication — no API call needed.
  */
 declare function useTradingWallet(walletAddress: string | undefined): UseTradingWalletReturn;
@@ -282,6 +395,23 @@ type UseTradingWalletBalanceParams = ReadHookParams<RadfiWalletBalance, {
 }>;
 declare function useTradingWalletBalance({ params, queryOptions, }?: UseTradingWalletBalanceParams): UseQueryResult<RadfiWalletBalance, Error>;
 
+interface UseBitcoinTradingSetupParams {
+    chainKey: SpokeChainKey;
+    /** This side's wallet provider + account, e.g. `useWalletProvider` / `useXAccount`. */
+    walletProvider: IWalletProvider | undefined;
+    address: string | undefined;
+}
+interface BitcoinTradingSetup {
+    wallet: IBitcoinWalletProvider | undefined;
+    tradingBalance: RadfiWalletBalance | undefined;
+}
+/**
+ * Bitcoin trading-wallet setup for one side of a cross-chain flow: Bitcoin funds move through a
+ * Bound Exchange (Radfi) trading wallet, not the personal wallet. Inert (no work) unless `chainKey`
+ * is Bitcoin. Wallet-layer inputs are passed in — this package doesn't depend on wallet-sdk-react.
+ */
+declare function useBitcoinTradingSetup({ chainKey, walletProvider, address, }: UseBitcoinTradingSetupParams): BitcoinTradingSetup;
+
 type UseExpiredUtxosParams = ReadHookParams<RadfiUtxo[], {
     walletProvider: IBitcoinWalletProvider | undefined;
     tradingAddress: string | undefined;
@@ -293,7 +423,7 @@ type UseRenewUtxosVars = {
     walletProvider: IBitcoinWalletProvider;
 };
 /**
- * React hook for renewing expired UTXOs in the user's Radfi trading wallet. Pure mutation: pass
+ * React hook for renewing expired UTXOs in the user's Bound Exchange trading wallet. Pure mutation: pass
  * `{ txIdVouts, walletProvider }` to `mutate({...})`.
  */
 declare function useRenewUtxos({ mutationOptions, }?: MutationHookParams<string, UseRenewUtxosVars>): SafeUseMutationResult<string, Error, UseRenewUtxosVars>;
@@ -309,7 +439,7 @@ type WithdrawResult = {
     fee: number;
 };
 /**
- * React hook for withdrawing BTC from the user's Radfi trading wallet back to their personal
+ * React hook for withdrawing BTC from the user's Bound Exchange trading wallet back to their personal
  * Bitcoin wallet. Pure mutation: pass all inputs (including the wallet provider) to
  * `mutate({...})`.
  */
@@ -649,50 +779,6 @@ type UseBackendUserIntentsParams = ReadHookParams<UserIntentsResponse | undefine
  */
 declare const useBackendUserIntents: ({ params, queryOptions, }?: UseBackendUserIntentsParams) => UseQueryResult<UserIntentsResponse | undefined, Error>;
 
-/**
- * Mutation variables for {@link useBackendSubmitSwapTx}. The per-request `apiConfig` override
- * (e.g. base URL) belongs here rather than at the hook level — different submissions in the same
- * component can target different endpoints without re-rendering.
- */
-type UseBackendSubmitSwapTxVars = {
-    request: SubmitSwapTxRequest;
-    apiConfig?: RequestOverrideConfig;
-};
-/**
- * React hook for submitting a swap transaction to be processed by the backend (relay, post
- * execution to solver, etc.).
- *
- * Pure mutation: pass `{ request, apiConfig? }` to `mutate({...})`. Default `retry: 3` is applied
- * at the hook level — consumers can override via `mutationOptions.retry`.
- *
- * @example
- * const { mutateAsync: submitSwapTx, isPending, error } = useBackendSubmitSwapTx();
- *
- * const result = await submitSwapTx({
- *   request: { txHash: '0x123...', srcChainKey: 'sonic', walletAddress: '0xabc...', intent: { ... }, relayData: '0x...' },
- *   apiConfig: { baseURL: 'https://...' },
- * });
- */
-declare const useBackendSubmitSwapTx: ({ mutationOptions, }?: MutationHookParams<SubmitSwapTxResponse, UseBackendSubmitSwapTxVars>) => SafeUseMutationResult<SubmitSwapTxResponse, Error, UseBackendSubmitSwapTxVars>;
-
-type UseBackendSubmitSwapTxStatusParams = ReadHookParams<SubmitSwapTxStatusResponse | undefined, {
-    txHash: string | undefined;
-    srcChainKey?: string;
-    apiConfig?: RequestOverrideConfig;
-}>;
-/**
- * React hook for polling the processing status of a submitted swap transaction.
- *
- * @example
- * const { data: status } = useBackendSubmitSwapTxStatus({
- *   params: { txHash: '0x123...', srcChainKey: 'sonic' },
- * });
- *
- * @remarks
- * - Default refetch interval is 1 second; stops on 'executed' or 'failed' status.
- */
-declare const useBackendSubmitSwapTxStatus: ({ params, queryOptions, }?: UseBackendSubmitSwapTxStatusParams) => UseQueryResult<SubmitSwapTxStatusResponse | undefined, Error>;
-
 type BackendPaginationParams = {
     offset: string;
     limit: string;
@@ -783,6 +869,358 @@ type UseBackendAllMoneyMarketBorrowersParams = ReadHookParams<MoneyMarketBorrowe
  */
 declare const useBackendAllMoneyMarketBorrowers: ({ params, queryOptions, }?: UseBackendAllMoneyMarketBorrowersParams) => UseQueryResult<MoneyMarketBorrowers | undefined>;
 
+type UseSwapsApiTokensParams = ReadHookParams<GetSwapTokensResponseV2, {
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to fetch all supported swap tokens grouped by SpokeChainKey via the swaps API —
+ * `sodax.api.swaps.getTokens`.
+ *
+ * @example
+ * const { data: tokensByChain } = useSwapsApiTokens();
+ */
+declare const useSwapsApiTokens: ({ params, queryOptions, }?: UseSwapsApiTokensParams) => UseQueryResult<GetSwapTokensResponseV2, Error>;
+
+type UseSwapsApiTokensByChainParams = ReadHookParams<GetSwapTokensByChainResponseV2 | undefined, {
+    chainKey: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to fetch supported swap tokens for a single SpokeChainKey via the swaps API —
+ * `sodax.api.swaps.getTokensByChain`.
+ *
+ * @example
+ * const { data: tokens } = useSwapsApiTokensByChain({ params: { chainKey: '0xa4b1.arbitrum' } });
+ */
+declare const useSwapsApiTokensByChain: ({ params, queryOptions, }?: UseSwapsApiTokensByChainParams) => UseQueryResult<GetSwapTokensByChainResponseV2 | undefined, Error>;
+
+type UseSwapsApiQuoteParams = ReadHookParams<QuoteResponseV2 | undefined, {
+    body: QuoteRequestV2 | undefined;
+    query?: QuoteQueryV2;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to get a solver quote for a cross-chain swap via the swaps API —
+ * `sodax.api.swaps.getQuote`. Pass `query.includeTxData = true` to also build an unsigned
+ * create-intent transaction (`txData`); `srcAddress`/`dstAddress` are then required in the body.
+ *
+ * @example
+ * const { data: quote } = useSwapsApiQuote({
+ *   params: {
+ *     body: {
+ *       tokenSrc: '0x...', tokenSrcChainKey: '0xa4b1.arbitrum',
+ *       tokenDst: '0x...', tokenDstChainKey: 'sonic',
+ *       amount: '1000000', quoteType: 'exact_input',
+ *     },
+ *   },
+ * });
+ */
+declare const useSwapsApiQuote: ({ params, queryOptions, }?: UseSwapsApiQuoteParams) => UseQueryResult<QuoteResponseV2 | undefined, Error>;
+
+type UseSwapsApiDeadlineParams = ReadHookParams<DeadlineResponseV2, {
+    query?: DeadlineQueryV2;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to compute a swap deadline (hub timestamp + `offsetSeconds`, default 300s) via the
+ * swaps API — `sodax.api.swaps.getDeadline`.
+ *
+ * @example
+ * const { data: deadline } = useSwapsApiDeadline({ params: { query: { offsetSeconds: 600 } } });
+ */
+declare const useSwapsApiDeadline: ({ params, queryOptions, }?: UseSwapsApiDeadlineParams) => UseQueryResult<DeadlineResponseV2, Error>;
+
+type UseSwapsApiAllowanceParams = ReadHookParams<AllowanceCheckResponseV2 | undefined, {
+    body: CreateIntentParamsV2 | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to check whether the source-token allowance is already sufficient for an intent via
+ * the swaps API — `sodax.api.swaps.checkAllowance`. Returns `{ valid }`.
+ *
+ * @example
+ * const { data: allowance } = useSwapsApiAllowance({ params: { body: createIntentParams } });
+ */
+declare const useSwapsApiAllowance: ({ params, queryOptions, }?: UseSwapsApiAllowanceParams) => UseQueryResult<AllowanceCheckResponseV2 | undefined, Error>;
+
+/**
+ * Mutation variables for {@link useSwapsApiApprove}. The per-request `apiConfig` override belongs
+ * here rather than at the hook level — different calls in the same component can target different
+ * endpoints without re-rendering.
+ */
+type UseSwapsApiApproveVars = {
+    body: CreateIntentParamsV2;
+    apiConfig?: RequestOverrideConfig;
+};
+/**
+ * React hook to build an unsigned token-approval transaction for the source token via the swaps
+ * API — `sodax.api.swaps.approve`. Returns `{ tx }` (chain-specific unsigned tx) to sign and
+ * broadcast yourself; it does not change state, so no queries are invalidated.
+ *
+ * @example
+ * const { mutateAsync: approve } = useSwapsApiApprove();
+ * const { tx } = await approve({ body: createIntentParams });
+ */
+declare const useSwapsApiApprove: ({ mutationOptions, }?: MutationHookParams<ApproveResponseV2, UseSwapsApiApproveVars>) => SafeUseMutationResult<ApproveResponseV2, Error, UseSwapsApiApproveVars>;
+
+/**
+ * Mutation variables for {@link useSwapsApiCreateIntent}. The per-request `apiConfig` override
+ * belongs here rather than at the hook level.
+ */
+type UseSwapsApiCreateIntentVars = {
+    body: CreateIntentParamsV2;
+    apiConfig?: RequestOverrideConfig;
+};
+/**
+ * React hook to build an unsigned create-intent transaction via the swaps API —
+ * `sodax.api.swaps.createIntent`. Returns `{ tx, intent, relayData }` to sign and broadcast
+ * yourself; it does not change state, so no queries are invalidated.
+ *
+ * @example
+ * const { mutateAsync: createIntent } = useSwapsApiCreateIntent();
+ * const { tx, intent, relayData } = await createIntent({ body: createIntentParams });
+ */
+declare const useSwapsApiCreateIntent: ({ mutationOptions, }?: MutationHookParams<CreateIntentResponseV2, UseSwapsApiCreateIntentVars>) => SafeUseMutationResult<CreateIntentResponseV2, Error, UseSwapsApiCreateIntentVars>;
+
+/**
+ * Mutation variables for {@link useSwapsApiSubmitIntent}. The per-request `apiConfig` override
+ * belongs here rather than at the hook level.
+ */
+type UseSwapsApiSubmitIntentVars = {
+    body: SubmitIntentRequestV2;
+    apiConfig?: RequestOverrideConfig;
+};
+/**
+ * React hook to submit the broadcast intent tx to the relay via the swaps API —
+ * `sodax.api.swaps.submitIntent`. Returns `{ result }` (opaque relay response).
+ *
+ * No auto-retry (`retry: false`): submitting is non-idempotent — a retry after a lost response
+ * could double-submit to the relay. Override via `mutationOptions.retry` if your relay dedupes.
+ *
+ * @example
+ * const { mutateAsync: submitIntent } = useSwapsApiSubmitIntent();
+ * const { result } = await submitIntent({ body: { chainId: '146', txHash: '0x123...' } });
+ */
+declare const useSwapsApiSubmitIntent: ({ mutationOptions, }?: MutationHookParams<SubmitIntentResponseV2, UseSwapsApiSubmitIntentVars>) => SafeUseMutationResult<SubmitIntentResponseV2, Error, UseSwapsApiSubmitIntentVars>;
+
+type UseSwapsApiStatusParams = ReadHookParams<StatusResponseV2 | undefined, {
+    intentTxHash: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook for polling the solver intent status by hub-chain intent tx hash via the swaps API —
+ * `sodax.api.swaps.getStatus`. Returns `{ status, fillTxHash? }` (`fillTxHash` set when `status === 3`).
+ *
+ * @example
+ * const { data } = useSwapsApiStatus({ params: { intentTxHash: '0x123...' } });
+ *
+ * @remarks
+ * - Default refetch interval is 1 second; stops once `status` is `3` (SOLVED) or `4` (FAILED).
+ */
+declare const useSwapsApiStatus: ({ params, queryOptions, }?: UseSwapsApiStatusParams) => UseQueryResult<StatusResponseV2 | undefined, Error>;
+
+/**
+ * Terminal solver intent states: once reached, the intent is resolved and polling stops.
+ * `3` = SOLVED, `4` = FAILED (per `SwapIntentStatusCodeV2`); `-1` / `1` / `2` are non-terminal.
+ *
+ * Kept in its own pure module (no React/context imports) so it is unit-testable in dapp-kit's
+ * `node` test environment — importing the hook itself pulls in `useSodaxContext`.
+ */
+declare const isTerminalSwapIntentStatus: (status: SwapIntentStatusCodeV2 | undefined) => boolean;
+
+/**
+ * Mutation variables for {@link useSwapsApiCancelIntent}. The per-request `apiConfig` override
+ * belongs here rather than at the hook level.
+ */
+type UseSwapsApiCancelIntentVars = {
+    body: CancelIntentRequestV2;
+    apiConfig?: RequestOverrideConfig;
+};
+/**
+ * React hook to build an unsigned cancel-intent transaction via the swaps API —
+ * `sodax.api.swaps.cancelIntent`. The `intent` carries `bigint` numerics. Returns `{ tx }` to sign
+ * and broadcast yourself; it does not change state, so no queries are invalidated.
+ *
+ * @example
+ * const { mutateAsync: cancelIntent } = useSwapsApiCancelIntent();
+ * const { tx } = await cancelIntent({ body: { srcChainKey: 'sonic', intent } });
+ */
+declare const useSwapsApiCancelIntent: ({ mutationOptions, }?: MutationHookParams<CancelIntentResponseV2, UseSwapsApiCancelIntentVars>) => SafeUseMutationResult<CancelIntentResponseV2, Error, UseSwapsApiCancelIntentVars>;
+
+type UseSwapsApiIntentHashParams = ReadHookParams<IntentHashResponseV2 | undefined, {
+    intent: IntentRequestV2 | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to compute the keccak256 hash of an Intent struct via the swaps API —
+ * `sodax.api.swaps.getIntentHash`. The `intent` carries `bigint` numerics. Returns `{ hash }`.
+ *
+ * @example
+ * const { data } = useSwapsApiIntentHash({ params: { intent } });
+ */
+declare const useSwapsApiIntentHash: ({ params, queryOptions, }?: UseSwapsApiIntentHashParams) => UseQueryResult<IntentHashResponseV2 | undefined, Error>;
+
+type UseSwapsApiIntentPacketParams = ReadHookParams<IntentPacketResponseV2 | undefined, {
+    body: IntentPacketRequestV2 | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to long-poll the relayer until the fill packet lands on the destination chain via the
+ * swaps API — `sodax.api.swaps.getSolvedIntentPacket`. The request is held open server-side until
+ * the packet arrives (or `body.timeout` ms elapses), so no client-side `refetchInterval` is set.
+ *
+ * @example
+ * const { data: packet } = useSwapsApiIntentPacket({
+ *   params: { body: { chainId: '146', fillTxHash: '0x123...' } },
+ * });
+ */
+declare const useSwapsApiIntentPacket: ({ params, queryOptions, }?: UseSwapsApiIntentPacketParams) => UseQueryResult<IntentPacketResponseV2 | undefined, Error>;
+
+type UseSwapsApiIntentExtraDataParams = ReadHookParams<IntentExtraDataResponseV2 | undefined, {
+    body: IntentExtraDataRequestV2 | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to recover the relay extra data needed by `/swaps/intents/submit` via the swaps API —
+ * `sodax.api.swaps.getIntentSubmitTxExtraData`. Provide EITHER `txHash` OR `intent` in the body
+ * (whose `bigint` numerics are serialized by the SDK). Returns `{ address, payload }`.
+ *
+ * @example
+ * const { data } = useSwapsApiIntentExtraData({ params: { body: { txHash: '0x123...' } } });
+ */
+declare const useSwapsApiIntentExtraData: ({ params, queryOptions, }?: UseSwapsApiIntentExtraDataParams) => UseQueryResult<IntentExtraDataResponseV2 | undefined, Error>;
+
+type UseSwapsApiFilledIntentParams = ReadHookParams<IntentStateV2 | undefined, {
+    txHash: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to get the on-chain fill state for an intent by its hub-chain tx hash via the swaps
+ * API — `sodax.api.swaps.getFilledIntent`. Returns
+ * `{ exists, remainingInput, receivedOutput, pendingPayment }`.
+ *
+ * @example
+ * const { data: fill } = useSwapsApiFilledIntent({ params: { txHash: '0x123...' } });
+ */
+declare const useSwapsApiFilledIntent: ({ params, queryOptions, }?: UseSwapsApiFilledIntentParams) => UseQueryResult<IntentStateV2 | undefined, Error>;
+
+type UseSwapsApiIntentParams = ReadHookParams<GetIntentResponseV2 | undefined, {
+    txHash: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to look up an Intent struct by its hub-chain creation tx hash via the swaps API —
+ * `sodax.api.swaps.getIntent`. The decoded intent's bigint fields are returned as decimal strings.
+ *
+ * @example
+ * const { data: intent } = useSwapsApiIntent({ params: { txHash: '0x123...' } });
+ */
+declare const useSwapsApiIntent: ({ params, queryOptions, }?: UseSwapsApiIntentParams) => UseQueryResult<GetIntentResponseV2 | undefined, Error>;
+
+/**
+ * Mutation variables for {@link useSwapsApiCreateLimitOrder}. The per-request `apiConfig` override
+ * belongs here rather than at the hook level.
+ */
+type UseSwapsApiCreateLimitOrderVars = {
+    body: CreateLimitOrderParamsV2;
+    apiConfig?: RequestOverrideConfig;
+};
+/**
+ * React hook to build an unsigned create-limit-order-intent transaction via the swaps API —
+ * `sodax.api.swaps.createLimitOrderIntent` (same as create-intent but `deadline` is optional).
+ * Returns `{ tx, intent, relayData }`; it does not change state, so no queries are invalidated.
+ *
+ * @example
+ * const { mutateAsync: createLimitOrder } = useSwapsApiCreateLimitOrder();
+ * const { tx, intent, relayData } = await createLimitOrder({ body: createLimitOrderParams });
+ */
+declare const useSwapsApiCreateLimitOrder: ({ mutationOptions, }?: MutationHookParams<CreateLimitOrderResponseV2, UseSwapsApiCreateLimitOrderVars>) => SafeUseMutationResult<CreateLimitOrderResponseV2, Error, UseSwapsApiCreateLimitOrderVars>;
+
+type UseSwapsApiEstimateGasParams = ReadHookParams<GasEstimateResponseV2 | undefined, {
+    body: GasEstimateRequestV2 | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to estimate gas for a raw transaction on a spoke chain via the swaps API —
+ * `sodax.api.swaps.estimateGas`. Returns `{ gas }` (chain-specific shape).
+ *
+ * @example
+ * const { data } = useSwapsApiEstimateGas({ params: { body: { chainKey: 'sonic', tx } } });
+ */
+declare const useSwapsApiEstimateGas: ({ params, queryOptions, }?: UseSwapsApiEstimateGasParams) => UseQueryResult<GasEstimateResponseV2 | undefined, Error>;
+
+type UseSwapsApiPartnerFeeParams = ReadHookParams<FeeResponseV2 | undefined, {
+    amount: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to compute the partner fee for a given input amount via the swaps API —
+ * `sodax.api.swaps.getPartnerFee`. Returns `{ fee }` (decimal string).
+ *
+ * @example
+ * const { data } = useSwapsApiPartnerFee({ params: { amount: '1000000' } });
+ */
+declare const useSwapsApiPartnerFee: ({ params, queryOptions, }?: UseSwapsApiPartnerFeeParams) => UseQueryResult<FeeResponseV2 | undefined, Error>;
+
+type UseSwapsApiSolverFeeParams = ReadHookParams<FeeResponseV2 | undefined, {
+    amount: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook to compute the protocol (solver) fee for a given input amount via the swaps API —
+ * `sodax.api.swaps.getSolverFee`. Returns `{ fee }` (decimal string).
+ *
+ * @example
+ * const { data } = useSwapsApiSolverFee({ params: { amount: '1000000' } });
+ */
+declare const useSwapsApiSolverFee: ({ params, queryOptions, }?: UseSwapsApiSolverFeeParams) => UseQueryResult<FeeResponseV2 | undefined, Error>;
+
+/**
+ * Mutation variables for {@link useSwapsApiSubmitTx}. The per-request `apiConfig` override
+ * (e.g. base URL) belongs here rather than at the hook level — different submissions in the same
+ * component can target different endpoints without re-rendering.
+ */
+type UseSwapsApiSubmitTxVars = {
+    request: SubmitTxRequestV2;
+    apiConfig?: RequestOverrideConfig;
+};
+/**
+ * React hook for submitting a swap transaction to be processed (relay, post execution to the
+ * solver, etc.) via the swaps API — `sodax.api.swaps.submitTx`.
+ *
+ * Pure mutation: pass `{ request, apiConfig? }` to `mutate({...})`. Default `retry: 3` is applied
+ * at the hook level — consumers can override via `mutationOptions.retry`.
+ *
+ * @example
+ * const { mutateAsync: submitSwapTx, isPending, error } = useSwapsApiSubmitTx();
+ *
+ * const result = await submitSwapTx({
+ *   request: { txHash: '0x123...', srcChainKey: 'sonic', walletAddress: '0xabc...', intent: { ... }, relayData: '0x...' },
+ *   apiConfig: { baseURL: 'https://...' },
+ * });
+ */
+declare const useSwapsApiSubmitTx: ({ mutationOptions, }?: MutationHookParams<SubmitTxResponseV2, UseSwapsApiSubmitTxVars>) => SafeUseMutationResult<SubmitTxResponseV2, Error, UseSwapsApiSubmitTxVars>;
+
+type UseSwapsApiSubmitTxStatusParams = ReadHookParams<SubmitTxStatusResponseV2 | undefined, {
+    txHash: string | undefined;
+    srcChainKey?: string;
+    apiConfig?: RequestOverrideConfig;
+}>;
+/**
+ * React hook for polling the processing status of a submitted swap transaction via the swaps API —
+ * `sodax.api.swaps.getSubmitTxStatus`. Both `txHash` and `srcChainKey` are required for the query
+ * to run (the swaps API v2 status query requires the source chain key).
+ *
+ * @example
+ * const { data: status } = useSwapsApiSubmitTxStatus({
+ *   params: { txHash: '0x123...', srcChainKey: 'sonic' },
+ * });
+ *
+ * @remarks
+ * - Default refetch interval is 1 second; stops on 'solved' or 'failed' status.
+ */
+declare const useSwapsApiSubmitTxStatus: ({ params, queryOptions, }?: UseSwapsApiSubmitTxStatusParams) => UseQueryResult<SubmitTxStatusResponseV2 | undefined, Error>;
+
 /**
  * Mutation variables for {@link useBridge}. Generic over `K extends SpokeChainKey` (defaults to
  * the full union). Sophisticated callers can lock K at the hook call site to narrow the
@@ -1092,6 +1530,75 @@ type UseFeeClaimSwapVars = Omit<PartnerFeeClaimSwapAction<HubChainKey, false>, '
  */
 declare function useFeeClaimSwap({ mutationOptions, }?: MutationHookParams<IntentAutoSwapResult, UseFeeClaimSwapVars>): SafeUseMutationResult<IntentAutoSwapResult, Error, UseFeeClaimSwapVars>;
 
+type UsePartnerCancelIntentVars = Omit<PartnerFeeClaimCancelAction<HubChainKey, false>, 'raw'>;
+/**
+ * React hook to cancel a stuck partner fee-claim auto-swap intent and recover the locked tokens.
+ *
+ * Calls `ProtocolIntents.cancelIntent(fromToken, toToken)` — the only authorized cancel path for
+ * partner auto-swap intents (the generic swap-cancel reverts because ProtocolIntents, not the
+ * partner, is the intent creator). The contract cancels the intent and refunds the input amount to
+ * the partner. Use this to recover funds from an unfillable same-token claim.
+ *
+ * Throws on SDK failure so React Query's native error model engages. Returns the transaction hash.
+ */
+declare function usePartnerCancelIntent({ mutationOptions, }?: MutationHookParams<TxReturnType<HubChainKey, false>, UsePartnerCancelIntentVars>): SafeUseMutationResult<TxReturnType<HubChainKey, false>, Error, UsePartnerCancelIntentVars>;
+
+type UseGetUserIntentParams = ReadHookParams<Hex, Partial<GetUserIntentParams>>;
+/**
+ * React hook to look up the stored intent hash for a partner's `(user, fromToken, toToken)` pair.
+ *
+ * A non-zero hash means an open auto-swap intent exists for that token pair (e.g. an unfilled
+ * same-token claim) and can be recovered via {@link usePartnerCancelIntent}. Disabled until all
+ * three inputs are present. Throws on `!ok`.
+ */
+declare function useGetUserIntent({ params, queryOptions }?: UseGetUserIntentParams): UseQueryResult<Hex, Error>;
+
+type UseGetIntentDetailsParams = ReadHookParams<Intent, {
+    intentHash: Hex | undefined;
+}>;
+/**
+ * React hook to fetch the full {@link Intent} details for a ProtocolIntents intent hash.
+ *
+ * Pair with {@link useGetUserIntent} to display a stuck intent (e.g. its locked `inputAmount`)
+ * before recovering it. Disabled when the hash is missing or the zero hash (no intent). Throws
+ * on `!ok`.
+ */
+declare function useGetIntentDetails({ params, queryOptions, }?: UseGetIntentDetailsParams): UseQueryResult<Intent, Error>;
+
+/**
+ * Mutation variables for {@link useFeeClaimWithdraw}. Maps a partner fee balance to a
+ * Sonic-sourced bridge: `feeToken` is the wrapped hub-asset address on Sonic
+ * (`PartnerFeeClaimAssetBalance.address`); `dstToken` is the original token address on
+ * `dstChainKey` (`PartnerFeeClaimAssetBalance.originalAddress`, or `feeToken` for same-chain
+ * delivery to a Sonic address).
+ */
+type UseFeeClaimWithdrawVars = {
+    params: {
+        srcAddress: string;
+        feeToken: Address$1;
+        amount: bigint;
+        dstChainKey: SpokeChainKey;
+        dstToken: string;
+        recipient: string;
+    };
+    walletProvider: GetWalletProviderType<HubChainKey>;
+};
+/**
+ * React hook to withdraw a partner fee token directly to the partner's wallet **without a swap**.
+ *
+ * For fees the partner wants to keep as-is (the desired output equals the fee token, e.g. BTC→BTC),
+ * an auto-swap is impossible — the solver rejects a same-token swap. This bridges the wrapped fee
+ * token from Sonic to its native chain (or transfers it on Sonic when `dstChainKey` is Sonic),
+ * bypassing the solver entirely.
+ *
+ * Bridging from Sonic pulls the token via the partner's hub-wallet router, which requires a prior
+ * allowance to that spender — a different approval than the ProtocolIntents one used by the swap
+ * claim. Use `useBridgeAllowance` / `useBridgeApprove` (with the same mapped bridge params) first.
+ *
+ * Throws on SDK failure so React Query's native error model engages. Returns the `TxHashPair`.
+ */
+declare function useFeeClaimWithdraw({ mutationOptions, }?: MutationHookParams<TxHashPair, UseFeeClaimWithdrawVars>): SafeUseMutationResult<TxHashPair, Error, UseFeeClaimWithdrawVars>;
+
 type UseHubAssetBalancesParams = ReadHookParams<HubAssetBalance[], {
     chainKey: SpokeChainKey | undefined;
     /** The user's address on the spoke chain. The SDK derives the hub wallet abstraction internally. */
@@ -1475,16 +1982,205 @@ type UseClaimRewardsVars<K extends SpokeChainKey = SpokeChainKey> = Omit<ClLiqui
  */
 declare function useClaimRewards<K extends SpokeChainKey = SpokeChainKey>({ mutationOptions, }?: MutationHookParams<TxHashPair, UseClaimRewardsVars<K>>): SafeUseMutationResult<TxHashPair, Error, UseClaimRewardsVars<K>>;
 
+type UseLeverageYieldEffectiveAprParams = ReadHookParams<LeverageYieldEffectiveApr, {
+    vault: Address$1 | undefined;
+}>;
+/**
+ * Reads a leverage-yield vault's effective APR — AAVE supply/borrow rates plus the LSD
+ * staking yield, with the vault's leverage formula re-applied on the boosted supply side.
+ *
+ * The underlying SDK call does the on-chain reads (AAVE rates + `targetLTV`) and the
+ * off-chain LSD fetch in parallel. Rates drift slowly, so the default refresh is 60s.
+ *
+ * @example
+ * ```typescript
+ * const { data: apr } = useLeverageYieldEffectiveApr({ params: { vault: vault.vault } });
+ * ```
+ */
+declare function useLeverageYieldEffectiveApr({ params, queryOptions, }?: UseLeverageYieldEffectiveAprParams): UseQueryResult<LeverageYieldEffectiveApr, Error>;
+
+type UseLeverageYieldPositionParams = ReadHookParams<LeverageYieldPosition, {
+    vault: Address$1 | undefined;
+}>;
+/**
+ * Reads a leverage-yield vault's live position snapshot via the vault's `getPositionDetails`:
+ * collateral, debt, current LTV (drift vs `targetLTV`), health factor (∞ when no debt), and
+ * idle (not-yet-deployed) asset.
+ *
+ * LTV shifts with each rebalance/rate tick, so the default refresh (30s) is faster than the
+ * APR/stats reads.
+ *
+ * @example
+ * ```typescript
+ * const { data: position } = useLeverageYieldPosition({ params: { vault: vault.vault } });
+ * ```
+ */
+declare function useLeverageYieldPosition({ params, queryOptions, }?: UseLeverageYieldPositionParams): UseQueryResult<LeverageYieldPosition, Error>;
+
+type UseLeverageYieldTotalAssetsParams = ReadHookParams<bigint, {
+    vault: Address$1 | undefined;
+}>;
+/**
+ * Reads a leverage-yield vault's total underlying assets (vault-asset units, 18 decimals) —
+ * i.e. its TVL. Moves slowly, so the default refresh is 60s.
+ *
+ * @example
+ * ```typescript
+ * const { data: tvl } = useLeverageYieldTotalAssets({ params: { vault: vault.vault } });
+ * ```
+ */
+declare function useLeverageYieldTotalAssets({ params, queryOptions, }?: UseLeverageYieldTotalAssetsParams): UseQueryResult<bigint, Error>;
+
+type UseLeverageYieldPreviewRedeemParams = ReadHookParams<bigint, {
+    vault: Address$1 | undefined;
+    shares: bigint | undefined;
+}>;
+/**
+ * Reads the assets received for redeeming `shares` of a leverage-yield vault (ERC-4626
+ * `previewRedeem`). Passing `10n ** 18n` (one share) yields the per-share price that creeps
+ * up as the vault accrues interest. Moves slowly, so the default refresh is 60s.
+ *
+ * @example
+ * ```typescript
+ * const { data: sharePrice } = useLeverageYieldPreviewRedeem({
+ *   params: { vault: vault.vault, shares: 10n ** 18n },
+ * });
+ * ```
+ */
+declare function useLeverageYieldPreviewRedeem({ params, queryOptions, }?: UseLeverageYieldPreviewRedeemParams): UseQueryResult<bigint, Error>;
+
+/** A single `(chain, hub-wallet holder, share balance)` row produced by {@link useLeverageYieldShareBalances}. */
+type LeverageYieldShareHolding = {
+    chainKey: SpokeChainKey;
+    holder: Address$1;
+    shares: bigint;
+};
+/** A `(chainKey, EOA address)` pair the user controls — one per spoke chain they may hold shares under. */
+type LeverageYieldShareHolder = {
+    chainKey: SpokeChainKey;
+    address: string;
+};
+type UseLeverageYieldShareBalancesParams = ReadHookParams<LeverageYieldShareHolding, {
+    vault: Address$1 | undefined;
+    holders: readonly LeverageYieldShareHolder[] | undefined;
+}>;
+/**
+ * Reads a user's leverage-vault share (`lsoda*`) balances across every chain they may hold a
+ * position under — one query per holder, fanned out via `useQueries`.
+ *
+ * For each `(chainKey, address)` the holder is resolved to the address that actually owns the
+ * shares: the user's **derived hub wallet** on every chain, including the hub itself. Leverage
+ * deposits always deliver `lsoda*` to `getUserHubWalletAddress(srcAddress, srcChainKey)` (the
+ * CREATE3 user-router on Sonic for a hub-sourced deposit, the per-spoke hub wallet otherwise) —
+ * never the bare EOA — so a hub-chain deposit's shares live in the router, not the signing EOA.
+ * Resolving the holder the same way the deposit does is what makes a Sonic-sourced position show
+ * up here instead of reading a stale zero off the EOA.
+ *
+ * Returns the raw `useQueries` result array (15s refresh per query); callers aggregate as needed
+ * (e.g. sum `shares` for a headline total, or pick the row for the active chain).
+ *
+ * `useQueries` has no top-level options slot, so `queryOptions` is spread into every individual
+ * query config (and applies uniformly to each holder's query).
+ *
+ * @example
+ * ```typescript
+ * const balances = useLeverageYieldShareBalances({ params: { vault: vault.vault, holders } });
+ * const total = balances.reduce((acc, q) => acc + (q.data?.shares ?? 0n), 0n);
+ * ```
+ */
+declare function useLeverageYieldShareBalances({ params, queryOptions, }?: UseLeverageYieldShareBalancesParams): UseQueryResult<LeverageYieldShareHolding, Error>[];
+
+/** Mutation variables for {@link useLeverageYieldDeposit} — the swap-style deposit inputs. */
+type UseLeverageYieldDepositVars = LeverageYieldSwapDepositParams;
+/**
+ * Builds the `LeverageYieldSwapPayload` for a leverage-yield deposit (any token → `lsoda*` shares,
+ * delivered to the user's hub wallet). Spread the returned payload into
+ * {@link useLeverageYieldVaultSwap}.
+ *
+ * This is a builder, not an executor — it derives the hub wallet and assembles the intent; the
+ * actual swap is relayed by `useLeverageYieldVaultSwap`. Throws on SDK failure so React Query's
+ * error model engages; returns the unwrapped `LeverageYieldSwapPayload` on success.
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsyncSafe: buildDeposit } = useLeverageYieldDeposit();
+ * const built = await buildDeposit({ vault, srcChainKey, srcAddress, inputToken, inputAmount, minOutputAmount });
+ * if (built.ok) vaultSwap({ ...built.value, walletProvider });
+ * ```
+ */
+declare function useLeverageYieldDeposit({ mutationOptions, }?: MutationHookParams<LeverageYieldSwapPayload, UseLeverageYieldDepositVars>): SafeUseMutationResult<LeverageYieldSwapPayload, Error, UseLeverageYieldDepositVars>;
+
+/** Mutation variables for {@link useLeverageYieldNotifySolver} — the hub-side intent tx hash. */
+type UseLeverageYieldNotifySolverVars = SolverExecutionRequest;
+/**
+ * Notifies the solver that a leverage-yield vault intent landed on the hub, triggering the fill.
+ * The standalone notify step for the manual create → relay → notify flow: build the intent with
+ * `sodax.leverageYield.createVaultIntent`, relay it yourself, then call this with the hub-side
+ * intent tx hash. The end-to-end {@link useLeverageYieldVaultSwap} already calls notifySolver
+ * internally — only reach for this hook when driving the relay manually.
+ *
+ * Throws on SDK failure so React Query's error model engages; returns the unwrapped
+ * `SolverExecutionResponse` (`{ answer: 'OK', intent_hash }`) on success.
+ */
+declare function useLeverageYieldNotifySolver({ mutationOptions, }?: MutationHookParams<SolverExecutionResponse, UseLeverageYieldNotifySolverVars>): SafeUseMutationResult<SolverExecutionResponse, Error, UseLeverageYieldNotifySolverVars>;
+
+/**
+ * Mutation variables for {@link useLeverageYieldVaultSwap}. 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.
+ */
+type UseLeverageYieldVaultSwapVars<K extends SpokeChainKey = SpokeChainKey> = Omit<VaultSwapActionParams<K, false>, 'raw'>;
+/**
+ * React hook for executing an end-to-end leverage-yield vault swap (deposit or withdraw).
+ *
+ * Spread a `LeverageYieldSwapPayload` built by {@link useLeverageYieldDeposit} /
+ * {@link useLeverageYieldWithdraw} into `mutate` alongside the wallet provider:
+ * `vaultSwap({ ...payload, walletProvider })`. Runs `sodax.leverageYield.vaultSwap` —
+ * create intent → verify → relay → notify solver — so vault flows never touch the
+ * generic swap surface.
+ *
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped `VaultSwapResponse` on success.
+ */
+declare function useLeverageYieldVaultSwap<K extends SpokeChainKey = SpokeChainKey>({ mutationOptions, }?: MutationHookParams<VaultSwapResponse, UseLeverageYieldVaultSwapVars<K>>): SafeUseMutationResult<VaultSwapResponse, Error, UseLeverageYieldVaultSwapVars<K>>;
+
+/** Mutation variables for {@link useLeverageYieldWithdraw} — the swap-style withdraw inputs. */
+type UseLeverageYieldWithdrawVars = LeverageYieldSwapWithdrawParams;
+/**
+ * Builds the `LeverageYieldSwapPayload` for a leverage-yield withdraw (`lsoda*` shares → any token).
+ * The returned payload carries `hubWalletSwap: true`; spread it into
+ * {@link useLeverageYieldVaultSwap}, which authorises the hub wallet to spend the shares via a
+ * `Connection.sendMessage`.
+ *
+ * This is a builder, not an executor. Throws on SDK failure so React Query's error model engages;
+ * returns the unwrapped `LeverageYieldSwapPayload` on success.
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsyncSafe: buildWithdraw } = useLeverageYieldWithdraw();
+ * const built = await buildWithdraw({ vault, srcChainKey, srcAddress, dstChainKey, outputToken, inputAmount, minOutputAmount });
+ * if (built.ok) vaultSwap({ ...built.value, walletProvider });
+ * ```
+ */
+declare function useLeverageYieldWithdraw({ mutationOptions, }?: MutationHookParams<LeverageYieldSwapPayload, UseLeverageYieldWithdrawVars>): SafeUseMutationResult<LeverageYieldSwapPayload, Error, UseLeverageYieldWithdrawVars>;
+
 interface SodaxProviderProps {
     children: ReactNode;
     /**
-     * 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.
+     * Sodax SDK config. Tracked by **reference** - a new identity re-instantiates the
+     * SDK. Hoist to a module constant or wrap in `useMemo`; include any value the SDK
+     * should react to (e.g. solver env) in the deps. Inline `{...}` re-creates the SDK
+     * every parent render and resets every `useSodaxContext` consumer.
+     *
+     * @example
+     * ```tsx
+     * const config = useMemo(() => ({ solver: solverMap[env] }), [env]);
+     * <SodaxProvider config={config}>...</SodaxProvider>
+     * ```
      */
-    config?: DeepPartial<SodaxConfig>;
+    config?: SodaxOptions;
 }
+/** Root provider for `@sodax/dapp-kit`. Must be paired with `QueryClientProvider`. */
 declare const SodaxProvider: ({ children, config }: SodaxProviderProps) => ReactElement;
 
 type CreateSodaxQueryClientOptions = {
@@ -1547,4 +2243,30 @@ type CreateSodaxQueryClientOptions = {
  */
 declare function createSodaxQueryClient({ onMutationError, config, }?: CreateSodaxQueryClientOptions): QueryClient;
 
-export { type ATokenData, type BackendPaginationParams, type CreateSodaxQueryClientOptions, type DecreaseLiquidityParamsCore, type DepositParamsCore, type MutationHookOptions, type MutationHookParams, type RadfiSession, type ReadHookParams, type ReadQueryOptions, type ReserveUsdFormat, type SafeUseMutationResult, SodaxProvider, type UseATokenParams, type UseATokensBalancesParams, type UseApproveTokenVars, type UseBitcoinBalanceParams, type UseBorrowVars, type UseBridgeAllowanceParams, type UseBridgeApproveVars, type UseBridgeVars, type UseClaimRewardsVars, type UseCreateDecreaseLiquidityParamsProps, type UseCreateDepositParamsProps, type UseCreateLimitOrderVars, type UseCreateSupplyLiquidityParamsProps, type UseCreateSupplyLiquidityParamsResult, type UseCreateWithdrawParamsProps, type UseDecreaseLiquidityVars, type UseDeriveUserWalletAddressParams, type UseDexAllowanceParams, type UseDexApproveVars, type UseDexDepositVars, type UseDexWithdrawVars, type UseExpiredUtxosParams, type UseFeeClaimSwapVars, type UseFetchAssetsBalancesParams, type UseFundTradingWalletVars, type UseGetAutoSwapPreferencesParams, type UseGetBridgeableAmountParams, type UseGetBridgeableTokensParams, type UseGetUserHubWalletAddressParams, type UseHubAssetBalancesParams, type UseIsTokenApprovedParams, type UseLiquidityAmountsResult, type UseMMAllowanceParams, type UseMMApproveVars, type UseMigrateBalnVars, type UseMigrateIcxToSodaVars, type UseMigratebnUSDVars, type UseMigrationAllowanceInputs, type UseMigrationAllowanceParams, type UseMigrationApproveVars, type UsePoolBalancesParams, type UsePoolBalancesResponse, type UsePoolDataParams, type UsePoolsParams, type UsePositionInfoParams, type UsePositionInfoResponse, type UseQuoteParams, type UseRadfiAuthVars, type UseRadfiSessionReturn, type UseRadfiWithdrawVars, type UseRenewUtxosVars, type UseRepayVars, type UseReservesDataParams, type UseReservesHumanizedParams, type UseReservesListParams, type UseReservesUsdFormatParams, type UseRevertMigrateSodaToIcxVars, type UseSetSwapPreferenceVars, type UseSetSwapPreferenceVarsHub, type UseStatusParams, type UseStellarTrustlineCheckParams, type UseSupplyLiquidityVars, type UseSupplyVars, type UseSwapAllowanceParams, type UseSwapApproveVars, type UseSwapVars, type UseTradingWalletBalanceParams, type UseUserFormattedSummaryParams, type UseUserReservesDataParams, type UseWithdrawHubAssetVars, type UseWithdrawVars, type UseXBalancesParams, type WithdrawParamsCore, type XBalancesInputs, clearRadfiSession, createDecreaseLiquidityParamsProps, createDepositParamsProps, createSodaxQueryClient, createSupplyLiquidityParamsProps, createWithdrawParamsProps, getXBalancesQueryOptions, loadRadfiSession, saveRadfiSession, toResult, unwrapResult, useAToken, useATokensBalances, useApproveToken, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendSubmitSwapTx, useBackendSubmitSwapTxStatus, useBackendUserIntents, useBitcoinBalance, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useClaimRewards, useConvertedAssets, useCreateDecreaseLiquidityParams, useCreateDepositParams, useCreateLimitOrder, useCreateSupplyLiquidityParams, useCreateWithdrawParams, useDecreaseLiquidity, useDeriveUserWalletAddress, useDexAllowance, useDexApprove, useDexDeposit, useDexWithdraw, useEstimateGas, useExpiredUtxos, useFeeClaimSwap, useFetchAssetsBalances, useFundTradingWallet, useGetAutoSwapPreferences, useGetBridgeableAmount, useGetBridgeableTokens, useGetUserHubWalletAddress, useHubAssetBalances, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useIsTokenApproved, useLiquidityAmounts, useMMAllowance, useMMApprove, useMigrateBaln, useMigrateIcxToSoda, useMigratebnUSD, useMigrationAllowance, useMigrationApprove, usePoolBalances, usePoolData, usePools, usePositionInfo, useQuote, useRadfiAuth, useRadfiSession, useRadfiWithdraw, useRenewUtxos, useRepay, useRequestTrustline, useReservesData, useReservesHumanized, useReservesList, useReservesUsdFormat, useRevertMigrateSodaToIcx, useSafeMutation, useSetSwapPreference, useSodaxContext, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSupplyLiquidity, useSwap, useSwapAllowance, useSwapApprove, useTradingWallet, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw, useWithdrawHubAsset, useXBalances };
+/** The subset of a `useNearStorageCheck` result the gate reads. A full `UseQueryResult<boolean>` satisfies it. */
+type NearStorageCheckResult = Pick<UseQueryResult<boolean>, 'isLoading' | 'data'>;
+/** UI gate state for NEP-141 storage registration on NEAR. */
+interface NearStorageGateState {
+    /** Destination is NEAR — the only chain with a NEP-141 storage-registration prerequisite. */
+    isNear: boolean;
+    /** Show the "register storage" action: the check resolved and the recipient is not registered. */
+    needsRegistration: boolean;
+    /**
+     * Keep the downstream action (swap/bridge/borrow/withdraw) disabled: the NEAR gate is unresolved
+     * (still checking) or unmet (needs registration).
+     */
+    blocksAction: boolean;
+}
+/**
+ * Derives the NEP-141 storage-registration UI gate state for a flow that delivers a token to a user
+ * on NEAR — NEAR's analogue of the Stellar trustline gate. Unwrapped (no hook): pass the destination
+ * `chainKey` and the `useNearStorageCheck` result; the util owns the `=== NEAR` test and reads
+ * `isLoading` (NOT `isPending`, which stays `true` for a disabled query and would block forever).
+ *
+ * `blocksAction` deliberately also covers the in-flight check window so the action can't be
+ * triggered before registration status is known; `needsRegistration` only flips once the check has
+ * resolved (so the "register" button isn't shown speculatively while still checking).
+ */
+declare function resolveNearStorageGate(chainKey: SpokeChainKey, check: NearStorageCheckResult): NearStorageGateState;
+
+export { type ATokenData, type BackendPaginationParams, type BitcoinTradingSetup, type CreateSodaxQueryClientOptions, type DecreaseLiquidityParamsCore, type DepositParamsCore, type LeverageYieldShareHolder, type LeverageYieldShareHolding, type MutationHookOptions, type MutationHookParams, type NearStorageCheckResult, type NearStorageGateState, type RadfiSession, type ReadHookParams, type ReadQueryOptions, type ReserveUsdFormat, type SafeUseMutationResult, SodaxProvider, type UseATokenParams, type UseATokensBalancesParams, type UseApproveTokenVars, type UseBitcoinBalanceParams, type UseBitcoinTradingSetupParams, type UseBorrowVars, type UseBridgeAllowanceParams, type UseBridgeApproveVars, type UseBridgeVars, type UseClaimRewardsVars, type UseCreateDecreaseLiquidityParamsProps, type UseCreateDepositParamsProps, type UseCreateLimitOrderVars, type UseCreateSupplyLiquidityParamsProps, type UseCreateSupplyLiquidityParamsResult, type UseCreateWithdrawParamsProps, type UseDecreaseLiquidityVars, type UseDeriveUserWalletAddressParams, type UseDexAllowanceParams, type UseDexApproveVars, type UseDexDepositVars, type UseDexWithdrawVars, type UseEnsureRadfiAccessTokenVars, type UseExpiredUtxosParams, type UseFeeClaimSwapVars, type UseFeeClaimWithdrawVars, type UseFetchAssetsBalancesParams, type UseFundTradingWalletVars, type UseGetAutoSwapPreferencesParams, type UseGetBridgeableAmountParams, type UseGetBridgeableTokensParams, type UseGetIntentDetailsParams, type UseGetUserHubWalletAddressParams, type UseGetUserIntentParams, type UseHubAssetBalancesParams, type UseIsTokenApprovedParams, type UseLeverageYieldDepositVars, type UseLeverageYieldEffectiveAprParams, type UseLeverageYieldNotifySolverVars, type UseLeverageYieldPositionParams, type UseLeverageYieldPreviewRedeemParams, type UseLeverageYieldShareBalancesParams, type UseLeverageYieldTotalAssetsParams, type UseLeverageYieldVaultSwapVars, type UseLeverageYieldWithdrawVars, type UseLiquidityAmountsResult, type UseMMAllowanceParams, type UseMMApproveVars, type UseMigrateBalnVars, type UseMigrateIcxToSodaVars, type UseMigratebnUSDVars, type UseMigrationAllowanceInputs, type UseMigrationAllowanceParams, type UseMigrationApproveVars, type UseNearStorageCheckParams, type UsePartnerCancelIntentVars, type UsePoolBalancesParams, type UsePoolBalancesResponse, type UsePoolDataParams, type UsePoolsParams, type UsePositionInfoParams, type UsePositionInfoResponse, type UseQuoteParams, type UseRadfiAuthVars, type UseRadfiSessionReturn, type UseRadfiWithdrawVars, type UseRegisterNearStorageVars, type UseRenewUtxosVars, type UseRepayVars, type UseReservesDataParams, type UseReservesHumanizedParams, type UseReservesListParams, type UseReservesUsdFormatParams, type UseRevertMigrateSodaToIcxVars, type UseSetSwapPreferenceVars, type UseSetSwapPreferenceVarsHub, type UseStatusParams, type UseStellarTrustlineCheckParams, type UseSupplyLiquidityVars, type UseSupplyVars, type UseSwapAllowanceParams, type UseSwapApproveVars, type UseSwapVars, type UseSwapsApiAllowanceParams, type UseSwapsApiApproveVars, type UseSwapsApiCancelIntentVars, type UseSwapsApiCreateIntentVars, type UseSwapsApiCreateLimitOrderVars, type UseSwapsApiDeadlineParams, type UseSwapsApiEstimateGasParams, type UseSwapsApiFilledIntentParams, type UseSwapsApiIntentExtraDataParams, type UseSwapsApiIntentHashParams, type UseSwapsApiIntentPacketParams, type UseSwapsApiIntentParams, type UseSwapsApiPartnerFeeParams, type UseSwapsApiQuoteParams, type UseSwapsApiSolverFeeParams, type UseSwapsApiStatusParams, type UseSwapsApiSubmitIntentVars, type UseSwapsApiSubmitTxStatusParams, type UseSwapsApiSubmitTxVars, type UseSwapsApiTokensByChainParams, type UseSwapsApiTokensParams, type UseTradingWalletBalanceParams, type UseUserFormattedSummaryParams, type UseUserReservesDataParams, type UseWithdrawHubAssetVars, type UseWithdrawVars, type UseXBalancesParams, type WithdrawParamsCore, type XBalancesInputs, clearRadfiSession, createDecreaseLiquidityParamsProps, createDepositParamsProps, createSodaxQueryClient, createSupplyLiquidityParamsProps, createWithdrawParamsProps, getXBalancesQueryOptions, isTerminalSwapIntentStatus, isUserRejectedError, loadRadfiSession, resolveNearStorageGate, saveRadfiSession, toResult, unwrapResult, useAToken, useATokensBalances, useApproveToken, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendUserIntents, useBitcoinBalance, useBitcoinTradingSetup, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useClaimRewards, useConvertedAssets, useCreateDecreaseLiquidityParams, useCreateDepositParams, useCreateLimitOrder, useCreateSupplyLiquidityParams, useCreateWithdrawParams, useDecreaseLiquidity, useDeriveUserWalletAddress, useDexAllowance, useDexApprove, useDexDeposit, useDexWithdraw, useEnsureRadfiAccessToken, useEstimateGas, useExpiredUtxos, useFeeClaimSwap, useFeeClaimWithdraw, useFetchAssetsBalances, useFundTradingWallet, useGetAutoSwapPreferences, useGetBridgeableAmount, useGetBridgeableTokens, useGetIntentDetails, useGetUserHubWalletAddress, useGetUserIntent, useHubAssetBalances, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useIsTokenApproved, useLeverageYieldDeposit, useLeverageYieldEffectiveApr, useLeverageYieldNotifySolver, useLeverageYieldPosition, useLeverageYieldPreviewRedeem, useLeverageYieldShareBalances, useLeverageYieldTotalAssets, useLeverageYieldVaultSwap, useLeverageYieldWithdraw, useLiquidityAmounts, useMMAllowance, useMMApprove, useMigrateBaln, useMigrateIcxToSoda, useMigratebnUSD, useMigrationAllowance, useMigrationApprove, useNearStorageCheck, useNearStorageGate, usePartnerCancelIntent, usePoolBalances, usePoolData, usePools, usePositionInfo, useQuote, useRadfiAuth, useRadfiSession, useRadfiWithdraw, useRegisterNearStorage, useRenewUtxos, useRepay, useRequestTrustline, useReservesData, useReservesHumanized, useReservesList, useReservesUsdFormat, useRevertMigrateSodaToIcx, useSafeMutation, useSetSwapPreference, useSodaxContext, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSupplyLiquidity, useSwap, useSwapAllowance, useSwapApprove, useSwapsApiAllowance, useSwapsApiApprove, useSwapsApiCancelIntent, useSwapsApiCreateIntent, useSwapsApiCreateLimitOrder, useSwapsApiDeadline, useSwapsApiEstimateGas, useSwapsApiFilledIntent, useSwapsApiIntent, useSwapsApiIntentExtraData, useSwapsApiIntentHash, useSwapsApiIntentPacket, useSwapsApiPartnerFee, useSwapsApiQuote, useSwapsApiSolverFee, useSwapsApiStatus, useSwapsApiSubmitIntent, useSwapsApiSubmitTx, useSwapsApiSubmitTxStatus, useSwapsApiTokens, useSwapsApiTokensByChain, useTradingWallet, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw, useWithdrawHubAsset, useXBalances };