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

package/src/hooks/leverageYield/useLeverageYieldPreviewRedeem.ts

@@ -0,0 +1,43 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { Address } from '@sodax/sdk';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseLeverageYieldPreviewRedeemParams = ReadHookParams<
+  bigint,
+  { vault: Address | 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 },
+ * });
+ * ```
+ */
+export function useLeverageYieldPreviewRedeem({
+  params,
+  queryOptions,
+}: UseLeverageYieldPreviewRedeemParams = {}): UseQueryResult<bigint, Error> {
+  const { sodax } = useSodaxContext();
+  const vault = params?.vault;
+  const shares = params?.shares;
+
+  return useQuery<bigint, Error>({
+    queryKey: ['leverageYield', 'previewRedeem', vault, shares?.toString()],
+    queryFn: async () => {
+      if (!vault || shares === undefined) throw new Error('vault and shares are required');
+      const result = await sodax.leverageYield.previewRedeem(vault, shares);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!vault && shares !== undefined,
+    refetchInterval: 60_000,
+    ...queryOptions,
+  });
+}

package/src/hooks/leverageYield/useLeverageYieldShareBalances.ts

@@ -0,0 +1,74 @@
+import { useQueries, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { Address, SpokeChainKey } from '@sodax/sdk';
+import type { ReadHookParams } from '../shared/types.js';
+
+/** A single `(chain, hub-wallet holder, share balance)` row produced by {@link useLeverageYieldShareBalances}. */
+export type LeverageYieldShareHolding = {
+  chainKey: SpokeChainKey;
+  holder: Address;
+  shares: bigint;
+};
+
+/** A `(chainKey, EOA address)` pair the user controls — one per spoke chain they may hold shares under. */
+export type LeverageYieldShareHolder = {
+  chainKey: SpokeChainKey;
+  address: string;
+};
+
+export type UseLeverageYieldShareBalancesParams = ReadHookParams<
+  LeverageYieldShareHolding,
+  { vault: Address | 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);
+ * ```
+ */
+export function useLeverageYieldShareBalances({
+  params,
+  queryOptions,
+}: UseLeverageYieldShareBalancesParams = {}): UseQueryResult<LeverageYieldShareHolding, Error>[] {
+  const { sodax } = useSodaxContext();
+  const vault = params?.vault;
+  const holders = params?.holders;
+
+  return useQueries({
+    queries: (holders ?? []).map(({ chainKey, address }) => ({
+      queryKey: ['leverageYield', 'shareBalance', vault, chainKey, address] as const,
+      refetchInterval: 15_000,
+      ...queryOptions,
+      enabled: !!vault,
+      queryFn: async (): Promise<LeverageYieldShareHolding> => {
+        if (!vault) throw new Error('vault is required');
+        // Always the derived hub wallet — on the hub chain too. A leverage deposit delivers
+        // shares to getUserHubWalletAddress(...), the CREATE3 router on Sonic, never the EOA,
+        // so reading balanceOf(EOA) for the hub chain would always come back zero.
+        const holder = await sodax.hubProvider.getUserHubWalletAddress(address, chainKey);
+        const result = await sodax.leverageYield.getShareBalance(vault, holder);
+        if (!result.ok) throw result.error;
+        return { chainKey, holder, shares: result.value };
+      },
+    })),
+  });
+}

package/src/hooks/leverageYield/useLeverageYieldTotalAssets.ts

@@ -0,0 +1,36 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { Address } from '@sodax/sdk';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseLeverageYieldTotalAssetsParams = ReadHookParams<bigint, { vault: Address | 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 } });
+ * ```
+ */
+export function useLeverageYieldTotalAssets({
+  params,
+  queryOptions,
+}: UseLeverageYieldTotalAssetsParams = {}): UseQueryResult<bigint, Error> {
+  const { sodax } = useSodaxContext();
+  const vault = params?.vault;
+
+  return useQuery<bigint, Error>({
+    queryKey: ['leverageYield', 'totalAssets', vault],
+    queryFn: async () => {
+      if (!vault) throw new Error('vault is required');
+      const result = await sodax.leverageYield.getTotalAssets(vault);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!vault,
+    refetchInterval: 60_000,
+    ...queryOptions,
+  });
+}

package/src/hooks/leverageYield/useLeverageYieldVaultSwap.ts

@@ -0,0 +1,50 @@
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { SpokeChainKey, VaultSwapActionParams, VaultSwapResponse } 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';
+
+/**
+ * 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.
+ */
+export 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.
+ */
+export function useLeverageYieldVaultSwap<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<VaultSwapResponse, UseLeverageYieldVaultSwapVars<K>> = {}): SafeUseMutationResult<
+  VaultSwapResponse,
+  Error,
+  UseLeverageYieldVaultSwapVars<K>
+> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useSafeMutation<VaultSwapResponse, Error, UseLeverageYieldVaultSwapVars<K>>({
+    mutationKey: ['leverageYield', 'vaultSwap'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.leverageYield.vaultSwap({ ...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/leverageYield/useLeverageYieldWithdraw.ts

@@ -0,0 +1,40 @@
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { LeverageYieldSwapPayload, LeverageYieldSwapWithdrawParams } from '@sodax/sdk';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+
+/** Mutation variables for {@link useLeverageYieldWithdraw} — the swap-style withdraw inputs. */
+export 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 });
+ * ```
+ */
+export function useLeverageYieldWithdraw({
+  mutationOptions,
+}: MutationHookParams<LeverageYieldSwapPayload, UseLeverageYieldWithdrawVars> = {}): SafeUseMutationResult<
+  LeverageYieldSwapPayload,
+  Error,
+  UseLeverageYieldWithdrawVars
+> {
+  const { sodax } = useSodaxContext();
+
+  return useSafeMutation<LeverageYieldSwapPayload, Error, UseLeverageYieldWithdrawVars>({
+    mutationKey: ['leverageYield', 'withdraw'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.leverageYield.withdraw(vars)),
+  });
+}

package/src/hooks/mm/useATokensBalances.ts

@@ -2,6 +2,7 @@ import type { SpokeChainKey } from '@sodax/sdk';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import { type Address, isAddress } from 'viem';
 import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { resolveBtcReadAddress } from '../bitcoin/resolveBtcReadAddress.js';
 import type { ReadHookParams } from '../shared/types.js';
 
 export type UseATokensBalancesParams = ReadHookParams<
@@ -42,7 +43,12 @@ export function useATokensBalances({
         }
       }
 
-      const hubWalletAddress = await sodax.hubProvider.getUserHubWalletAddress(userAddress, spokeChainKey);
+      // Bitcoin positions live under the trading-wallet-derived hub wallet; resolve it locally
+      // (no network) so a Bound Exchange outage never reads a real position as empty.
+      const hubWalletAddress = await sodax.hubProvider.getUserHubWalletAddress(
+        resolveBtcReadAddress(spokeChainKey, userAddress),
+        spokeChainKey,
+      );
       return sodax.moneyMarket.data.getATokensBalances(aTokens, hubWalletAddress);
     },
     enabled: aTokens.length > 0 && !!spokeChainKey && !!userAddress,

package/src/hooks/mm/useUserFormattedSummary.ts

@@ -2,6 +2,7 @@ import type { FormatReserveUSDResponse, FormatUserSummaryResponse } from '@sodax
 import type { SpokeChainKey } from '@sodax/sdk';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { resolveBtcReadAddress } from '../bitcoin/resolveBtcReadAddress.js';
 import type { ReadHookParams } from '../shared/types.js';
 
 export type UseUserFormattedSummaryParams = ReadHookParams<
@@ -36,7 +37,10 @@ export function useUserFormattedSummary({
 
       const [reserves, userReserves] = await Promise.all([
         sodax.moneyMarket.data.getReservesHumanized(),
-        sodax.moneyMarket.data.getUserReservesHumanized(spokeChainKey, userAddress),
+        sodax.moneyMarket.data.getUserReservesHumanized(
+          spokeChainKey,
+          resolveBtcReadAddress(spokeChainKey, userAddress),
+        ),
       ]);
       const formattedReserves = sodax.moneyMarket.data.formatReservesUSD(
         sodax.moneyMarket.data.buildReserveDataWithPrice(reserves),

package/src/hooks/mm/useUserReservesData.ts

@@ -2,6 +2,7 @@ import type { UserReserveData } from '@sodax/sdk';
 import type { SpokeChainKey } from '@sodax/sdk';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { resolveBtcReadAddress } from '../bitcoin/resolveBtcReadAddress.js';
 import type { ReadHookParams } from '../shared/types.js';
 
 export type UseUserReservesDataParams = ReadHookParams<
@@ -30,7 +31,10 @@ export function useUserReservesData({
       if (!spokeChainKey || !userAddress) {
         throw new Error('spokeChainKey and userAddress are required');
       }
-      return sodax.moneyMarket.data.getUserReservesData(spokeChainKey, userAddress);
+      return sodax.moneyMarket.data.getUserReservesData(
+        spokeChainKey,
+        resolveBtcReadAddress(spokeChainKey, userAddress),
+      );
     },
     enabled: !!spokeChainKey && !!userAddress,
     refetchInterval: 5000,

package/src/hooks/partner/index.ts

@@ -4,3 +4,7 @@ export * from './useIsTokenApproved.js';
 export * from './useApproveToken.js';
 export * from './useSetSwapPreference.js';
 export * from './useFeeClaimSwap.js';
+export * from './usePartnerCancelIntent.js';
+export * from './useGetUserIntent.js';
+export * from './useGetIntentDetails.js';
+export * from './useFeeClaimWithdraw.js';

package/src/hooks/partner/useFeeClaimWithdraw.ts

@@ -0,0 +1,88 @@
+// packages/dapp-kit/src/hooks/partner/useFeeClaimWithdraw.ts
+import {
+  ChainKeys,
+  type Address,
+  type BridgeParams,
+  type GetWalletProviderType,
+  type HubChainKey,
+  type SpokeChainKey,
+  type TxHashPair,
+} from '@sodax/sdk';
+import { useQueryClient } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+
+/**
+ * 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).
+ */
+export type UseFeeClaimWithdrawVars = {
+  params: {
+    srcAddress: string;
+    feeToken: Address;
+    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`.
+ */
+export function useFeeClaimWithdraw({
+  mutationOptions,
+}: MutationHookParams<TxHashPair, UseFeeClaimWithdrawVars> = {}): SafeUseMutationResult<
+  TxHashPair,
+  Error,
+  UseFeeClaimWithdrawVars
+> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useSafeMutation<TxHashPair, Error, UseFeeClaimWithdrawVars>({
+    mutationKey: ['partner', 'feeClaimWithdraw'],
+    ...mutationOptions,
+    mutationFn: async ({ params, walletProvider }) => {
+      const bridgeParams = {
+        params: {
+          srcChainKey: ChainKeys.SONIC_MAINNET,
+          srcAddress: params.srcAddress,
+          srcToken: params.feeToken,
+          amount: params.amount,
+          dstChainKey: params.dstChainKey,
+          dstToken: params.dstToken,
+          recipient: params.recipient,
+        },
+        raw: false,
+        walletProvider,
+      } satisfies BridgeParams<HubChainKey, false>;
+
+      return unwrapResult(await sodax.bridge.bridge(bridgeParams));
+    },
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ['partner', 'feeClaim', 'assetsBalances', vars.params.srcAddress],
+      });
+      queryClient.invalidateQueries({ queryKey: ['shared', 'xBalances', vars.params.dstChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    },
+  });
+}

package/src/hooks/partner/useGetIntentDetails.ts

@@ -0,0 +1,39 @@
+// packages/dapp-kit/src/hooks/partner/useGetIntentDetails.ts
+import type { Hex, Intent } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+const ZERO_HASH = '0x0000000000000000000000000000000000000000000000000000000000000000';
+
+export 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`.
+ */
+export function useGetIntentDetails({
+  params,
+  queryOptions,
+}: UseGetIntentDetailsParams = {}): UseQueryResult<Intent, Error> {
+  const { sodax } = useSodaxContext();
+  const intentHash = params?.intentHash;
+  const hasIntent = !!intentHash && intentHash !== ZERO_HASH;
+
+  return useQuery<Intent, Error>({
+    queryKey: ['partner', 'feeClaim', 'intentDetails', intentHash],
+    queryFn: async () => {
+      if (!intentHash) {
+        throw new Error('intentHash is required');
+      }
+      const result = await sodax.partners.feeClaim.getIntentDetails(intentHash);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: hasIntent,
+    ...queryOptions,
+  });
+}

package/src/hooks/partner/useGetUserIntent.ts

@@ -0,0 +1,35 @@
+// packages/dapp-kit/src/hooks/partner/useGetUserIntent.ts
+import type { GetUserIntentParams, Hex } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export 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`.
+ */
+export function useGetUserIntent({ params, queryOptions }: UseGetUserIntentParams = {}): UseQueryResult<Hex, Error> {
+  const { sodax } = useSodaxContext();
+  const user = params?.user;
+  const fromToken = params?.fromToken;
+  const toToken = params?.toToken;
+
+  return useQuery<Hex, Error>({
+    queryKey: ['partner', 'feeClaim', 'userIntent', user, fromToken, toToken],
+    queryFn: async () => {
+      if (!user || !fromToken || !toToken) {
+        throw new Error('user, fromToken and toToken are required');
+      }
+      const result = await sodax.partners.feeClaim.getUserIntent({ user, fromToken, toToken });
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!user && !!fromToken && !!toToken,
+    ...queryOptions,
+  });
+}

package/src/hooks/partner/usePartnerCancelIntent.ts

@@ -0,0 +1,52 @@
+// packages/dapp-kit/src/hooks/partner/usePartnerCancelIntent.ts
+import type { HubChainKey, PartnerFeeClaimCancelAction, TxReturnType } from '@sodax/sdk';
+import { useQueryClient } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+
+export 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.
+ */
+export function usePartnerCancelIntent({
+  mutationOptions,
+}: MutationHookParams<TxReturnType<HubChainKey, false>, UsePartnerCancelIntentVars> = {}): SafeUseMutationResult<
+  TxReturnType<HubChainKey, false>,
+  Error,
+  UsePartnerCancelIntentVars
+> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useSafeMutation<TxReturnType<HubChainKey, false>, Error, UsePartnerCancelIntentVars>({
+    mutationKey: ['partner', 'cancelIntent'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.partners.feeClaim.cancelIntent<false>({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ['partner', 'feeClaim', 'assetsBalances', vars.params.srcAddress],
+      });
+      queryClient.invalidateQueries({
+        queryKey: [
+          'partner',
+          'feeClaim',
+          'userIntent',
+          vars.params.srcAddress,
+          vars.params.fromToken,
+          vars.params.toToken,
+        ],
+      });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    },
+  });
+}

package/src/hooks/shared/index.ts

@@ -1,3 +1,4 @@
+export * from './isUserRejectedError.js';
 export * from './types.js';
 export * from './unwrapResult.js';
 export * from './useSafeMutation.js';
@@ -6,5 +7,8 @@ export * from './useEstimateGas.js';
 export * from './useDeriveUserWalletAddress.js';
 export * from './useStellarTrustlineCheck.js';
 export * from './useRequestTrustline.js';
+export * from './useNearStorageCheck.js';
+export * from './useRegisterNearStorage.js';
+export * from './useNearStorageGate.js';
 export * from './useGetUserHubWalletAddress.js';
 export * from './useXBalances.js';

package/src/hooks/shared/isUserRejectedError.test.ts

@@ -0,0 +1,42 @@
+import { SodaxError } from '@sodax/sdk';
+import { describe, expect, it } from 'vitest';
+import { isUserRejectedError } from './isUserRejectedError.js';
+
+describe('isUserRejectedError', () => {
+  it('matches SodaxError with code USER_REJECTED', () => {
+    const err = new SodaxError('USER_REJECTED', 'User rejected the request', { feature: 'swap' });
+    expect(isUserRejectedError(err)).toBe(true);
+  });
+
+  it('does not match SodaxError with any other code', () => {
+    const cases: SodaxError[] = [
+      new SodaxError('INTENT_CREATION_FAILED', 'sim revert', { feature: 'swap' }),
+      new SodaxError('VALIDATION_FAILED', 'user rejected by invariant', { feature: 'staking' }),
+      new SodaxError('APPROVE_FAILED', 'allowance', { feature: 'moneyMarket' }),
+      new SodaxError('EXECUTION_FAILED', 'orchestrator', { feature: 'bridge' }),
+      new SodaxError('UNKNOWN', 'fallback', { feature: 'dex' }),
+    ];
+    for (const err of cases) expect(isUserRejectedError(err)).toBe(false);
+  });
+
+  it('does not match a plain Error whose message contains rejection prose', () => {
+    // The predicate trusts SDK classification; it does NOT re-scan message content. A bare
+    // Error from outside the SDK boundary (e.g. a non-canonical throw in a queryFn) is not a
+    // canonical USER_REJECTED — it should fall through to the generic failure UI.
+    expect(isUserRejectedError(new Error('User rejected the request'))).toBe(false);
+  });
+
+  it('does not match viem-shaped objects or wallet-library shapes', () => {
+    expect(isUserRejectedError({ name: 'UserRejectedRequestError', message: 'denied' })).toBe(false);
+    expect(isUserRejectedError({ code: 4001, message: 'reject' })).toBe(false);
+    expect(isUserRejectedError({ code: 'ACTION_REJECTED' })).toBe(false);
+  });
+
+  it('does not match non-error values', () => {
+    expect(isUserRejectedError(undefined)).toBe(false);
+    expect(isUserRejectedError(null)).toBe(false);
+    expect(isUserRejectedError('User rejected the request')).toBe(false);
+    expect(isUserRejectedError({})).toBe(false);
+    expect(isUserRejectedError(0)).toBe(false);
+  });
+});

package/src/hooks/shared/isUserRejectedError.ts

@@ -0,0 +1,30 @@
+import { isSodaxError } from '@sodax/sdk';
+
+/**
+ * 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.
+ */
+export function isUserRejectedError(error: unknown): boolean {
+  return isSodaxError(error) && error.code === 'USER_REJECTED';
+}

package/src/hooks/shared/useGetUserHubWalletAddress.ts

@@ -1,6 +1,7 @@
 import type { SpokeChainKey } from '@sodax/sdk';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from './useSodaxContext.js';
+import { resolveBtcReadAddress } from '../bitcoin/resolveBtcReadAddress.js';
 import type { Address } from 'viem';
 import type { ReadHookParams } from './types.js';
 
@@ -44,7 +45,10 @@ export function useGetUserHubWalletAddress({
       if (!spokeChainId || !spokeAddress) {
         throw new Error('Spoke chain id and address are required');
       }
-      return await sodax.hubProvider.getUserHubWalletAddress(spokeAddress, spokeChainId);
+      return await sodax.hubProvider.getUserHubWalletAddress(
+        resolveBtcReadAddress(spokeChainId, spokeAddress),
+        spokeChainId,
+      );
     },
     enabled: !!spokeChainId && !!spokeAddress,
     refetchInterval: false,