@sodax/skills 2.0.0-rc.11 → 2.0.0-rc.13

package/.claude-plugin/plugin.json

@@ -7,6 +7,7 @@
     "./skills/sodax-sdk/bridge",
     "./skills/sodax-sdk/staking",
     "./skills/sodax-sdk/dex",
+    "./skills/sodax-sdk/leverage-yield",
     "./skills/sodax-sdk/migration",
     "./skills/sodax-sdk/partner",
     "./skills/sodax-sdk/recovery",
@@ -34,6 +35,7 @@
     "./skills/sodax-dapp-kit/staking",
     "./skills/sodax-dapp-kit/bridge",
     "./skills/sodax-dapp-kit/dex",
+    "./skills/sodax-dapp-kit/leverage-yield",
     "./skills/sodax-dapp-kit/migration",
     "./skills/sodax-dapp-kit/bitcoin",
     "./skills/sodax-dapp-kit/auxiliary-services"

package/AGENTS.md

@@ -8,10 +8,10 @@ This package ships **four mode-gated broad skills** (`skills/<name>/SKILL.md`)
 
 | SDK package | Broad skill | Granular per-feature skills |
 |---|---|---|
-| `@sodax/sdk` | `sodax-sdk` | `sodax-sdk/swap`, `sodax-sdk/money-market`, `sodax-sdk/bridge`, `sodax-sdk/staking`, `sodax-sdk/dex`, `sodax-sdk/migration`, `sodax-sdk/partner`, `sodax-sdk/recovery`, `sodax-sdk/backend-api` |
+| `@sodax/sdk` | `sodax-sdk` | `sodax-sdk/swap`, `sodax-sdk/money-market`, `sodax-sdk/bridge`, `sodax-sdk/staking`, `sodax-sdk/dex`, `sodax-sdk/leverage-yield`, `sodax-sdk/migration`, `sodax-sdk/partner`, `sodax-sdk/recovery`, `sodax-sdk/backend-api` |
 | `@sodax/wallet-sdk-core` | `sodax-wallet-sdk-core` | `sodax-wallet-sdk-core/evm`, `sodax-wallet-sdk-core/solana`, `sodax-wallet-sdk-core/sui`, `sodax-wallet-sdk-core/bitcoin`, `sodax-wallet-sdk-core/stellar`, `sodax-wallet-sdk-core/icon`, `sodax-wallet-sdk-core/injective`, `sodax-wallet-sdk-core/near`, `sodax-wallet-sdk-core/stacks` |
 | `@sodax/wallet-sdk-react` | `sodax-wallet-sdk-react` | `sodax-wallet-sdk-react/connect`, `sodax-wallet-sdk-react/wallet-modal`, `sodax-wallet-sdk-react/bridge-to-sdk`, `sodax-wallet-sdk-react/switch-chain`, `sodax-wallet-sdk-react/sign-message`, `sodax-wallet-sdk-react/walletconnect` |
-| `@sodax/dapp-kit` | `sodax-dapp-kit` | `sodax-dapp-kit/swap`, `sodax-dapp-kit/money-market`, `sodax-dapp-kit/staking`, `sodax-dapp-kit/bridge`, `sodax-dapp-kit/dex`, `sodax-dapp-kit/migration`, `sodax-dapp-kit/bitcoin`, `sodax-dapp-kit/auxiliary-services` |
+| `@sodax/dapp-kit` | `sodax-dapp-kit` | `sodax-dapp-kit/swap`, `sodax-dapp-kit/money-market`, `sodax-dapp-kit/staking`, `sodax-dapp-kit/bridge`, `sodax-dapp-kit/dex`, `sodax-dapp-kit/leverage-yield`, `sodax-dapp-kit/migration`, `sodax-dapp-kit/bitcoin`, `sodax-dapp-kit/auxiliary-services` |
 
 **When to prefer a granular skill:** if the consumer has already picked a sub-domain (e.g. *"swap with Sodax"*, *"supply on money market"*, *"useSwap hook"*, *"instantiate EvmWalletProvider"*, *"add a connect button"*), load the matching granular skill — it's ~3 KB vs the broad skill's ~13 KB and points at exactly the knowledge files needed. For a React dapp that has settled on one feature, load `sodax-dapp-kit/<feature>`; for raw SDK / backend work, load `sodax-sdk/<feature>`; for a known chain in a backend/Node wallet flow, load `sodax-wallet-sdk-core/<chain>`; for a known React wallet concern (connect, wallet-modal, bridge-to-sdk, switch-chain, sign-message, walletconnect), load `sodax-wallet-sdk-react/<concern>`. Load the broad skill when the sub-domain is undecided, the task spans several, or the consumer is porting a full v1 codebase.
 
@@ -23,8 +23,8 @@ Pick the consumer's situation, load the listed skills in order. Each entry names
 
 | Consumer is… | Load skills (mode) |
 |---|---|
-| **Scaffolding ONE specific Core SDK feature** (swap, money-market, bridge, staking, dex, migration, partner, recovery, backend-api) | `sodax-sdk/<feature>` (granular, covers both modes via internal links). Add `sodax-wallet-sdk-core` (integration) if it signs and lives outside React. Skip the broad `sodax-sdk` skill |
-| **Scaffolding ONE specific dapp-kit feature in React** (swap, money-market, staking, bridge, dex, migration, bitcoin, auxiliary-services) | `sodax-wallet-sdk-react` (integration) → `sodax-dapp-kit/<feature>` (granular, covers both modes via internal links). Skip the broad `sodax-dapp-kit` skill. If the wallet concern is also settled (just a connect button, modal, bridge, etc.), narrow to `sodax-wallet-sdk-react/<concern>` too |
+| **Scaffolding ONE specific Core SDK feature** (swap, money-market, bridge, staking, dex, leverage-yield, migration, partner, recovery, backend-api) | `sodax-sdk/<feature>` (granular, covers both modes via internal links). Add `sodax-wallet-sdk-core` (integration) if it signs and lives outside React. Skip the broad `sodax-sdk` skill |
+| **Scaffolding ONE specific dapp-kit feature in React** (swap, money-market, staking, bridge, dex, leverage-yield, migration, bitcoin, auxiliary-services) | `sodax-wallet-sdk-react` (integration) → `sodax-dapp-kit/<feature>` (granular, covers both modes via internal links). Skip the broad `sodax-dapp-kit` skill. If the wallet concern is also settled (just a connect button, modal, bridge, etc.), narrow to `sodax-wallet-sdk-react/<concern>` too |
 | **Scaffolding ONE chain's wallet provider** (backend/Node/non-React: evm, solana, sui, bitcoin, stellar, icon, injective, near, stacks) | `sodax-wallet-sdk-core/<chain>` (granular, covers both modes) → `sodax-sdk/<feature>` for the operation it signs. Skip the broad `sodax-wallet-sdk-core` skill |
 | **Scaffolding ONE React wallet concern** (connect, wallet-modal, bridge-to-sdk, switch-chain, sign-message, walletconnect) | `sodax-wallet-sdk-react/<concern>` (granular, covers both modes). Skip the broad `sodax-wallet-sdk-react` skill |
 | **Building a NEW React dapp** | `sodax-wallet-sdk-react` (integration) → `sodax-dapp-kit` (integration) → (`sodax-sdk` (integration) only if dropping below dapp-kit) |
@@ -58,8 +58,8 @@ packages/skills/
 ├── .claude-plugin/plugin.json             # Skill registry (broad + nested granular paths)
 └── skills/                                # Each broad skill is mode-gated; some have nested granular children
     ├── sodax-sdk/                         {SKILL.md, integration/knowledge/, migration-v1-to-v2/knowledge/,
-    │                                       <feature>/SKILL.md ×9 — swap, money-market, bridge, staking, dex,
-    │                                       migration, partner, recovery, backend-api}
+    │                                       <feature>/SKILL.md ×10 — swap, money-market, bridge, staking, dex,
+    │                                       leverage-yield, migration, partner, recovery, backend-api}
     ├── sodax-wallet-sdk-core/             {SKILL.md, integration/knowledge/, migration-v1-to-v2/knowledge/,
     │                                       <chain>/SKILL.md ×9 — evm, solana, sui, bitcoin, stellar, icon,
     │                                       injective, near, stacks}
@@ -68,8 +68,8 @@ packages/skills/
     │                                       <concern>/SKILL.md ×6 — connect, wallet-modal, bridge-to-sdk,
     │                                       switch-chain, sign-message, walletconnect}
     └── sodax-dapp-kit/                    {SKILL.md, integration/knowledge/, migration-v1-to-v2/knowledge/,
-                                            <feature>/SKILL.md ×8 — swap, money-market, staking, bridge, dex,
-                                            migration, bitcoin, auxiliary-services}
+                                            <feature>/SKILL.md ×9 — swap, money-market, staking, bridge, dex,
+                                            leverage-yield, migration, bitcoin, auxiliary-services}
 ```
 
 Each `<mode>/knowledge/` subtree contains `ai-rules.md`, `quickstart.md`, `architecture.md`, `features/`, `recipes/`, `reference/`, and `chain-specifics.md` / `breaking-changes/` where applicable.

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.0.0-rc.11",
+  "version": "2.0.0-rc.13",
   "license": "MIT",
   "description": "AI-agent skills and knowledge for consumers of @sodax/* SDKs (Claude Code, Codex, Cursor, …)",
   "keywords": [

package/skills/sodax-dapp-kit/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: sodax-dapp-kit
-description: 'INTEGRATION (write NEW code) — @sodax/dapp-kit is React hooks wrapping @sodax/sdk with React Query across 11 feature domains (swap, money market, staking, bridge, dex, migration, partner, recovery, bitcoin/Radfi, backend queries, shared). React-only — Node and backend code uses `@sodax/sdk` directly. Use whenever a React dapp needs SODAX feature hooks. Triggers on "use @sodax/dapp-kit", "useSwap", "useMoneyMarket", "useStake", "useBridge", "useDex", "useMigrate", any `use<Feature>` hook name from dapp-kit, "Sodax React hooks", "dapp-kit query / mutation". v2 hook shape: mutation hooks return `SafeUseMutationResult` with `mutateAsyncSafe(vars): Promise<Result<TData>>`. mutationFn unwraps SDK Result<T> and throws on `!ok` so React Query''s native error model engages. Hook-owned invalidations — consumer onSuccess runs after. MIGRATION (port v1 → v2) — a deep canonicalization pass: single-object hook params, mandatory `mutateAsyncSafe`, hook-owned invalidations, throw-on-`Result.!ok` inside `mutationFn`, canonical queryKey/mutationKey conventions. Plus the SDK underneath was reshaped (chain-key-driven routing, `Result<T>` everywhere, `WalletProviderSlot<K, Raw>`). v1 dapp-kit code will not compile against v2. Triggers on "migrate @sodax/dapp-kit", "useSpokeProvider gone", "dapp-kit v1 → v2", "invalidateMmQueries broken", "dapp-kit hook signatures changed", v1 fingerprints (positional args, hook-init `spokeProvider`, `useSpokeProvider`, `invalidateMmQueries`, legacy `useMigrate`, `*_MAINNET_CHAIN_ID`). Load this skill if EITHER applies; the body gates by mode.'
+description: 'INTEGRATION (write NEW code) — @sodax/dapp-kit is React hooks wrapping @sodax/sdk with React Query across 11 feature domains (swap, money market, staking, bridge, dex, migration, partner, recovery, bitcoin/Bound Exchange, backend queries, shared). React-only — Node and backend code uses `@sodax/sdk` directly. Use whenever a React dapp needs SODAX feature hooks. Triggers on "use @sodax/dapp-kit", "useSwap", "useMoneyMarket", "useStake", "useBridge", "useDex", "useMigrate", any `use<Feature>` hook name from dapp-kit, "Sodax React hooks", "dapp-kit query / mutation". v2 hook shape: mutation hooks return `SafeUseMutationResult` with `mutateAsyncSafe(vars): Promise<Result<TData>>`. mutationFn unwraps SDK Result<T> and throws on `!ok` so React Query''s native error model engages. Hook-owned invalidations — consumer onSuccess runs after. MIGRATION (port v1 → v2) — a deep canonicalization pass: single-object hook params, mandatory `mutateAsyncSafe`, hook-owned invalidations, throw-on-`Result.!ok` inside `mutationFn`, canonical queryKey/mutationKey conventions. Plus the SDK underneath was reshaped (chain-key-driven routing, `Result<T>` everywhere, `WalletProviderSlot<K, Raw>`). v1 dapp-kit code will not compile against v2. Triggers on "migrate @sodax/dapp-kit", "useSpokeProvider gone", "dapp-kit v1 → v2", "invalidateMmQueries broken", "dapp-kit hook signatures changed", v1 fingerprints (positional args, hook-init `spokeProvider`, `useSpokeProvider`, `invalidateMmQueries`, legacy `useMigrate`, `*_MAINNET_CHAIN_ID`). Load this skill if EITHER applies; the body gates by mode.'
 ---
 
 # When to use this skill
@@ -32,7 +32,7 @@ Pick this mode when the consumer is a React dapp using `@sodax/dapp-kit` hooks.
 1. Read [`integration/knowledge/ai-rules.md`](./integration/knowledge/ai-rules.md) — DO / DO NOT / workflow / stop conditions.
 2. Read [`integration/knowledge/quickstart.md`](./integration/knowledge/quickstart.md) — install + wire providers + first feature.
 3. Read [`integration/knowledge/architecture.md`](./integration/knowledge/architecture.md) — hook shapes, queryKey conventions, `useSafeMutation`, `unwrapResult`, `Result<T>`.
-4. For each feature you use, read [`integration/knowledge/features/`](./integration/knowledge/features/) — `swap.md`, `money-market.md`, `staking.md`, `bridge.md`, `dex.md`, `migration.md`, `bitcoin.md` (Radfi, dapp-kit-unique), `auxiliary-services.md` (partner + recovery + backend + shared).
+4. For each feature you use, read [`integration/knowledge/features/`](./integration/knowledge/features/) — `swap.md`, `money-market.md`, `staking.md`, `bridge.md`, `dex.md`, `migration.md`, `bitcoin.md` (Bound Exchange, dapp-kit-unique), `auxiliary-services.md` (partner + recovery + backend + shared).
 5. Recipes → [`integration/knowledge/recipes/`](./integration/knowledge/recipes/) — `setup.md`, `wallet-connectivity.md`, per-feature, `mutation-error-handling.md`, `observability.md`, `invalidations.md`.
 6. Lookups → [`integration/knowledge/reference/`](./integration/knowledge/reference/) — `hooks-index.md`, `querykey-conventions.md`, `public-api.md`, `glossary.md`.
 

package/skills/sodax-dapp-kit/integration/knowledge/README.md

@@ -15,7 +15,7 @@ This tree documents v2 of the dapp-kit React hooks for **new consumers** buildin
 | [`features/bridge.md`](features/bridge.md) | Bridge hooks: `useBridge`, allowance/approve, bridgeable amount/tokens. |
 | [`features/dex.md`](features/dex.md) | DEX hooks: deposit/withdraw, supply/decrease liquidity, claim rewards, position info, pools. |
 | [`features/migration.md`](features/migration.md) | Migration hooks: ICX/bnUSD/BALN forward + reverse, allowance/approve. |
-| [`features/bitcoin.md`](features/bitcoin.md) | Radfi hooks (dapp-kit-unique): session, trading wallet, fund/withdraw, UTXOs. |
+| [`features/bitcoin.md`](features/bitcoin.md) | Bound Exchange hooks (dapp-kit-unique): session, trading wallet, fund/withdraw, UTXOs. |
 | [`features/auxiliary-services.md`](features/auxiliary-services.md) | Partner, recovery, backend queries, shared (xBalances, gas estimation, trustlines). |
 | [`recipes/`](recipes/) | Copy-paste patterns: setup, wallet connectivity, per-feature flows, mutation error handling, observability, invalidations. |
 | [`reference/`](reference/) | Lookup tables: full hook index, queryKey conventions, public API surface, glossary. |

package/skills/sodax-dapp-kit/integration/knowledge/features/README.md

@@ -9,8 +9,9 @@ Per-feature reference docs. Each file documents the hooks, params types, return
 | [`staking.md`](staking.md) | SODA → xSODA staking: `useStake`, `useUnstake`, `useInstantUnstake`, `useClaim`, `useCancelUnstake`, allowance/approve, info/ratio reads. |
 | [`bridge.md`](bridge.md) | Cross-chain token bridging: `useBridge`, allowance/approve, bridgeable amount/tokens. |
 | [`dex.md`](dex.md) | Concentrated liquidity DEX: assets in/out, liquidity supply/decrease, claim rewards, position info, pool reads, param builders. |
+| [`leverage-yield.md`](leverage-yield.md) | Leveraged-yield ERC-4626 vaults: `useLeverageYieldDeposit`/`Withdraw` (build) + `useLeverageYieldVaultSwap` (execute), effective APR / position / TVL / share-balance reads. |
 | [`migration.md`](migration.md) | Token migration: `useMigrateIcxToSoda`, `useRevertMigrateSodaToIcx`, `useMigratebnUSD`, `useMigrateBaln`, allowance/approve. |
-| [`bitcoin.md`](bitcoin.md) | Radfi (dapp-kit-unique): session, trading wallet, fund/withdraw, UTXOs. |
+| [`bitcoin.md`](bitcoin.md) | Bound Exchange (dapp-kit-unique): session, trading wallet, fund/withdraw, UTXOs. |
 | [`auxiliary-services.md`](auxiliary-services.md) | Partner fee claiming, recovery, backend queries (intent tracking, orderbook, MM data), shared utilities (xBalances, gas, trustlines). |
 
 ## Reference vs recipes
@@ -20,7 +21,7 @@ Per-feature reference docs. Each file documents the hooks, params types, return
 
 ## Pair-completeness
 
-Every file in this directory has a sibling in [`features/`](../../../migration-v1-to-v2/knowledge/features/) with the same filename — the v1→v2 porting playbook for that feature. When you're deep in one, the other is one path-swap away.
+Every file in this directory has a sibling in [`features/`](../../../migration-v1-to-v2/knowledge/features/) with the same filename — the v1→v2 porting playbook for that feature. When you're deep in one, the other is one path-swap away. **Exception:** features introduced in v2 with no v1 equivalent (`leverage-yield.md`) have no migration sibling — there is nothing to port.
 
 ## Cross-references
 

package/skills/sodax-dapp-kit/integration/knowledge/features/auxiliary-services.md

@@ -94,6 +94,10 @@ useGetUserHubWalletAddress({ params, queryOptions }); // Hub wallet via wallet r
 useEstimateGas({ mutationOptions });                // Gas estimation for raw tx
 useStellarTrustlineCheck({ params, queryOptions });
 useRequestTrustline({ mutationOptions });
+useNearStorageCheck({ params, queryOptions });      // NEP-141 storage registration check (NEAR)
+useRegisterNearStorage({ mutationOptions });        // NEP-141 storage_deposit (NEAR)
+useNearStorageGate({ dstChainKey, token, accountId, walletProvider }); // composite NEAR receive-side gate
+resolveNearStorageGate(chainKey, check);            // unwrapped util: gate-state from a useNearStorageCheck result
 ```
 
 ### `useXBalances` shape
@@ -144,6 +148,46 @@ if (hasTrustline === false) {
 }
 ```
 
+### NEAR storage registration
+
+NEP-141 accounts must pay a one-time storage bond before they can receive a token — delivering to an unregistered account fails. The receive-side analogue of Stellar trustlines: gate any flow that delivers a token to the user on NEAR (swap output on NEAR, bridge into NEAR, money-market borrow/withdraw to NEAR). Use `useNearStorageGate` for app UI; use the lower-level `useNearStorageCheck` + `useRegisterNearStorage` pair when you need custom wiring.
+
+```ts
+// @ai-snippets-skip — illustrative only; real types pulled into agents below.
+// useNearStorageCheck is a canonical read hook: { params: { token, accountId, chainId }, queryOptions }.
+// `chainId` is a SpokeChainKey typed loosely — the hook returns `true` for non-NEAR chains (safe to
+// gate conditionally) and `true` for native NEAR (not a NEP-141 token). data is a boolean;
+// queryKey: ['shared', 'nearStorageCheck', chainId, token, accountId].
+const { data: isRegistered, isLoading } = useNearStorageCheck({
+  params: { token, accountId, chainId: ChainKeys.NEAR_MAINNET },
+});
+
+// useRegisterNearStorage IS a canonical mutation hook: { mutationOptions }, returns
+// SafeUseMutationResult. Domain inputs flow through mutate / mutateAsync / mutateAsyncSafe.
+// Vars: { token, accountId, walletProvider, deposit? } — deposit defaults to the NEP-141
+// storage bond (0.00125 NEAR). mutationKey: ['shared', 'registerNearStorage'].
+const { mutateAsyncSafe: registerStorage } = useRegisterNearStorage();
+if (isRegistered === false) {
+  await registerStorage({ token, accountId, walletProvider });
+}
+```
+
+For the common UI path, `useNearStorageGate` returns `{ isNear, needsRegistration, blocksAction, isChecking, isRegistering, registerStorage }`.
+
+Derive UI gate flags with the unwrapped `resolveNearStorageGate` util (no hook) when you need custom check/register composition:
+
+```ts
+// @ai-snippets-skip — illustrative only.
+// resolveNearStorageGate(chainKey, check) reads `isLoading` + `data` off the useNearStorageCheck
+// result and returns { isNear, needsRegistration, blocksAction }:
+//   needsRegistration — show the register action (check resolved AND not registered)
+//   blocksAction      — keep the downstream action disabled (still checking OR needs registration)
+const check = useNearStorageCheck({ params: { token, accountId, chainId: dstChainKey } });
+const { needsRegistration, blocksAction } = resolveNearStorageGate(dstChainKey, check);
+```
+
+The underlying SDK methods (`isStorageRegistered` / `registerStorage` on the NEAR spoke service, and the `NEAR_STORAGE_DEPOSIT` constant) are documented in the `sodax-sdk` skill (integration mode).
+
 ## Default polling intervals
 
 | Hook | Polling | Notes |

package/skills/sodax-dapp-kit/integration/knowledge/features/bitcoin.md

@@ -1,6 +1,6 @@
-# Bitcoin (Radfi) — `@sodax/dapp-kit`
+# Bitcoin (Bound Exchange) — `@sodax/dapp-kit`
 
-Bitcoin trading via the Radfi protocol — authenticate, fund a trading wallet, withdraw, manage UTXOs. **Dapp-kit-unique surface** (no SDK equivalent — these flows are React-shaped).
+Bitcoin trading via the Bound Exchange protocol — authenticate, fund a trading wallet, withdraw, manage UTXOs. **Dapp-kit-unique surface** (no SDK equivalent — these flows are React-shaped).
 
 Pair: [`features/bitcoin.md`](../../../migration-v1-to-v2/knowledge/features/bitcoin.md).
 
@@ -15,7 +15,7 @@ useTradingWallet(walletAddress);                 // Synchronous: read persisted
 
 // Balances
 useBitcoinBalance({ params: { address, rpcUrl? }, queryOptions });             // Personal wallet (default mempool.space)
-useTradingWalletBalance({ params: { walletProvider, tradingAddress }, queryOptions }); // Radfi API
+useTradingWalletBalance({ params: { walletProvider, tradingAddress }, queryOptions }); // Bound Exchange API
 
 // Operations
 useFundTradingWallet({ mutationOptions });
@@ -26,7 +26,7 @@ useRenewUtxos({ mutationOptions });
 
 ## Session flow
 
-Radfi requires authentication before trading operations. `useRadfiSession` handles the full lifecycle:
+Bound Exchange requires authentication before trading operations. `useRadfiSession` handles the full lifecycle:
 
 ```ts
 // @ai-snippets-skip
@@ -76,8 +76,8 @@ type RenewUtxosVars = { txIdVouts: string[]; walletProvider: IBitcoinWalletProvi
 
 1. **Authentication required before any trading operation.** `useRadfiSession` manages this automatically — gate buttons on `isAuthed`.
 2. **Trading wallet is created during first authentication** — not a separate step.
-3. **`useTradingWallet(walletAddress)` is synchronous** (no network call). It reads persisted Radfi session from localStorage. Use it when you don't have a `walletProvider` available yet but need the trading address.
-4. **PSBT signing flow for withdrawals.** Radfi server builds an unsigned PSBT, the user signs locally via the wallet provider, then submits back for co-signing and broadcast. The dapp-kit hook orchestrates this — consumers don't see PSBTs directly.
+3. **`useTradingWallet(walletAddress)` is synchronous** (no network call). It reads persisted Bound Exchange session from localStorage. Use it when you don't have a `walletProvider` available yet but need the trading address.
+4. **PSBT signing flow for withdrawals.** Bound Exchange server builds an unsigned PSBT, the user signs locally via the wallet provider, then submits back for co-signing and broadcast. The dapp-kit hook orchestrates this — consumers don't see PSBTs directly.
 5. **Session tokens are for API rate-limiting, not asset access.** Stored in localStorage keyed by wallet address. Compromise of localStorage data doesn't affect funds.
 6. **`useExpiredUtxos` polls every 60s** — set `queryOptions.refetchInterval: false` to disable while UI is hidden.
 

package/skills/sodax-dapp-kit/integration/knowledge/features/leverage-yield.md

@@ -0,0 +1,112 @@
+# Leverage Yield — `@sodax/dapp-kit`
+
+Leveraged-yield ERC-4626 vaults on the Sonic hub. Deposit any token → `lsoda*` vault shares, withdraw shares → any token; plus position / APR / TVL / share-balance reads. New in v2 (no v1 equivalent).
+
+## Hook surface
+
+```ts
+// @ai-snippets-skip
+// Mutations
+useLeverageYieldDeposit({ mutationOptions });   // build a deposit payload (any token → lsoda*)
+useLeverageYieldWithdraw({ mutationOptions });  // build a withdraw payload (lsoda* → any token; hubWalletSwap)
+useLeverageYieldVaultSwap({ mutationOptions });  // EXECUTE the built payload end-to-end
+useLeverageYieldNotifySolver({ mutationOptions }); // manual-flow: notify the solver after a self-driven relay
+
+// Reads
+useLeverageYieldEffectiveApr({ params, queryOptions });  // AAVE + LSD effective net APR (60s)
+useLeverageYieldPosition({ params, queryOptions });      // collateral/debt/ltv/healthFactor/idle (30s)
+useLeverageYieldTotalAssets({ params, queryOptions });   // vault TVL, 18-dp bigint (60s)
+useLeverageYieldPreviewRedeem({ params, queryOptions }); // assets for N shares; price-per-share (60s)
+useLeverageYieldShareBalances({ params, queryOptions }); // per-chain share balances via useQueries (15s)
+```
+
+`deposit` / `withdraw` are **builders** — they assemble a `LeverageYieldSwapPayload`, they do NOT broadcast. Spread the built payload into `useLeverageYieldVaultSwap`'s `mutate`, adding the `walletProvider`. There is no dedicated leverage-yield approve hook: the swap-style deposit approves the spoke-side asset manager, so reuse `useSwapApprove` / `useSwapAllowance` (see Approval pattern).
+
+## Mutation TVars
+
+```ts
+// @ai-snippets-skip
+// deposit — vars are the SDK's deposit params (any token → lsoda* on the hub wallet)
+type UseLeverageYieldDepositVars = LeverageYieldSwapDepositParams;
+//   { vault: Address; srcChainKey; srcAddress; inputToken; inputAmount: bigint;
+//     minOutputAmount: bigint; deadline?: bigint; solver?: Address; partnerFee? }
+
+// withdraw — lsoda* shares → any token on any chain (hub-wallet sourced)
+type UseLeverageYieldWithdrawVars = LeverageYieldSwapWithdrawParams;
+//   { vault: Address; srcChainKey; srcAddress; dstChainKey; outputToken;
+//     inputAmount: bigint; minOutputAmount: bigint; recipient?; deadline?; solver? }
+
+// vaultSwap — the executor. Spread the built payload + walletProvider.
+type UseLeverageYieldVaultSwapVars<K> = Omit<VaultSwapActionParams<K, false>, 'raw'>;
+//   = SpokeExecActionParams<K, false, CreateIntentParams<K>> & { hubWalletSwap?; partnerFee? }
+//   i.e. { params: CreateIntentParams<K>; walletProvider; hubWalletSwap?; partnerFee?; timeout? }
+
+// notifySolver — manual-flow notify step (vaultSwap already notifies internally)
+type UseLeverageYieldNotifySolverVars = SolverExecutionRequest;
+//   { intent_tx_hash: Hex }  — the hub-side tx hash where the intent landed
+```
+
+## Read shapes (key picks)
+
+```ts
+// @ai-snippets-skip
+// useLeverageYieldEffectiveApr — AAVE rates + LSD staking yield, leverage re-applied (data unwrapped)
+useLeverageYieldEffectiveApr({ params: { vault } })
+//   → UseQueryResult<LeverageYieldEffectiveApr>
+//   LeverageYieldEffectiveApr = LeverageYieldApr & { lsdApr, effectiveSupplyAprRay, effectiveNetAprRay }
+//   LeverageYieldApr = { supplyAprRay, borrowAprRay, targetLtvBps, leverageMultiplierWad, netAprRay } (RAY = 1e27)
+
+// useLeverageYieldPosition — live position snapshot
+useLeverageYieldPosition({ params: { vault } })
+//   → UseQueryResult<LeverageYieldPosition>
+//   LeverageYieldPosition = { collateral, debt, ltv, healthFactor, idleAsset } (all bigint)
+
+// useLeverageYieldPreviewRedeem — assets per shares; pass 1e18 for price-per-share
+useLeverageYieldPreviewRedeem({ params: { vault, shares: 10n ** 18n } })
+//   → UseQueryResult<bigint>
+
+// useLeverageYieldShareBalances — returns an ARRAY (one query per holder), NOT a single result
+useLeverageYieldShareBalances({ params: { vault, holders } })
+//   → UseQueryResult<LeverageYieldShareHolding>[]
+//   LeverageYieldShareHolding = { chainKey: SpokeChainKey; holder: Address; shares: bigint }
+//   holders: { chainKey: SpokeChainKey; address: string }[]  — one row per chain the user may hold under
+```
+
+## Approval pattern
+
+Leverage-yield has **no dedicated approve hook**. A deposit is a swap-style intent that bridges `inputToken` from the spoke chain, so it approves the spoke-side asset manager exactly like a swap — reuse the swap hooks. A withdraw needs no spoke-side approval: the payload carries `hubWalletSwap: true` and `vaultSwap` authorises the hub wallet to spend the `lsoda*` shares via a `Connection.sendMessage` the user signs on `srcChainKey`.
+
+| Flow | Token approved | Hook |
+|---|---|---|
+| `deposit` | spoke `inputToken` → asset manager | `useSwapApprove`, `useSwapAllowance` (swap domain) |
+| `withdraw` | none (hub-wallet `sendMessage` authorises the spend) | — |
+
+## Return shapes
+
+All read hooks here are **already unwrapped** — they throw on SDK `!ok` so `isError` / `error` / `retry` engage. Read `data` directly; do NOT branch on `data.ok`.
+
+| Hook | Returns |
+|---|---|
+| `useLeverageYieldDeposit` / `useLeverageYieldWithdraw` | `SafeUseMutationResult<LeverageYieldSwapPayload, Error, …>` (builder — `data` is the payload to spread into `useLeverageYieldVaultSwap`) |
+| `useLeverageYieldVaultSwap` | `SafeUseMutationResult<VaultSwapResponse, Error, …>` (`{ solverExecutionResponse, intent, intentDeliveryInfo }`) |
+| `useLeverageYieldNotifySolver` | `SafeUseMutationResult<SolverExecutionResponse, Error, …>` (`{ answer: 'OK', intent_hash }`) |
+| `useLeverageYieldEffectiveApr` | `UseQueryResult<LeverageYieldEffectiveApr, Error>` |
+| `useLeverageYieldPosition` | `UseQueryResult<LeverageYieldPosition, Error>` |
+| `useLeverageYieldTotalAssets` | `UseQueryResult<bigint, Error>` |
+| `useLeverageYieldPreviewRedeem` | `UseQueryResult<bigint, Error>` |
+| `useLeverageYieldShareBalances` | `UseQueryResult<LeverageYieldShareHolding, Error>[]` (array — one entry per holder) |
+
+## Gotchas
+
+1. **`deposit` / `withdraw` are builders, not executors.** Their `data` is a `LeverageYieldSwapPayload` — spread it into `useLeverageYieldVaultSwap`'s `mutate` with a `walletProvider` to actually run the swap. Calling them does not broadcast anything.
+2. **`useLeverageYieldShareBalances` returns an ARRAY, not a single query.** It fans out one `useQueries` row per holder. Aggregate yourself: `balances.reduce((acc, q) => acc + (q.data?.shares ?? 0n), 0n)`. `queryOptions` is spread into every per-holder query (no top-level options slot on `useQueries`).
+3. **The share-balance key segment is singular: `shareBalance`** (`['leverageYield', 'shareBalance', vault, chainKey, address]`) — one per holder, even though the hook name is plural.
+4. **Withdraw needs no spoke approval.** Don't gate it on `useSwapAllowance` — the hub-wallet `sendMessage` path approves the share spend internally. Only `deposit` needs the swap-domain allowance/approve pair.
+5. **Deposit's per-intent `partnerFee` must be reflected in the quote.** If you charge a deposit-only fee (e.g. 1%), `vaultSwap`'s underlying `createVaultIntent` deducts it from `inputAmount` before the swap — quote on the post-fee amount, or `minOutputAmount` becomes unfillable and the intent never settles.
+6. **`useLeverageYieldVaultSwap` invalidates xBalances on both chains** (`['shared', 'xBalances', srcChainKey]` and `dstChainKey`) on success. Compose your own `onSuccess` after the hook's — it runs first.
+7. **`useLeverageYieldNotifySolver` is for the manual flow only.** `useLeverageYieldVaultSwap` already notifies the solver internally — only reach for the standalone notify hook when you built the intent with `sodax.leverageYield.createVaultIntent` and relayed it yourself. It does NOT invalidate any queries: its only var is `{ intent_tx_hash }` (no chain context), and the fill lands asynchronously afterward.
+
+## Cross-references
+
+- [`../recipes/leverage-yield.md`](../recipes/leverage-yield.md) — full worked deposit / withdraw / reads examples.
+- For the underlying SDK leverage-yield surface (`LeverageYieldService`, `createVaultIntent`, `notifySolver`, APR math), load the `sodax-sdk` skill (integration mode) — its `features/leverage-yield.md`.

package/skills/sodax-dapp-kit/integration/knowledge/features/money-market.md

@@ -43,6 +43,8 @@ type UseUserFormattedSummaryParams = ReadHookParams<FormatUserSummaryResponse, {
   userAddress: string | undefined;
 }>;
 // Same shape on useUserReservesData. The hook derives the hub wallet from (spokeChainKey, userAddress) internally.
+// Bitcoin: always pass the personal address as userAddress — the hook transparently resolves to the
+// Bound Exchange trading-wallet-derived hub wallet when a session is active (local lookup, no network).
 
 // useAToken — single aToken metadata; FLAT (no chain/user fields)
 type UseATokenParams = ReadHookParams<ATokenData, {
@@ -57,10 +59,13 @@ type UseATokensBalancesParams = ReadHookParams<Map<Address, bigint>, {
   userAddress: string | undefined;
 }>;
 // Returns a Map keyed by aToken address. The hook resolves the hub wallet from (spokeChainKey, userAddress).
+// Bitcoin: always pass the personal address — trading-wallet resolution is automatic when a session exists.
 ```
 
 > **Read-side chain key is `spokeChainKey`, not `srcChainKey`.** Mutation hooks (`useSupply`/`useBorrow`/etc.) use `srcChainKey` because the request crosses chains and needs a source. Read hooks describe a user's position on a single spoke chain — the field is `spokeChainKey`. Applies to `useATokensBalances`, `useUserFormattedSummary`, and `useUserReservesData` (`useAToken` is metadata-only and takes neither). Don't grep-replace one for the other.
 
+> **Bitcoin `userAddress`**: always pass the **personal** address (the user's wallet address), not the Bound Exchange trading address. The read hooks (`useATokensBalances`, `useUserReservesData`, `useUserFormattedSummary`, `useGetUserHubWalletAddress`) automatically resolve to the trading-wallet-derived hub wallet when a Bound Exchange session is active — this is a local lookup with no network call and no throw on an unauthenticated session. See [`features/bitcoin.md`](bitcoin.md) for Bound Exchange session setup.
+
 ## Mutation params
 
 All four user mutations share the same TVars shape (only the `action` literal differs):

package/skills/sodax-dapp-kit/integration/knowledge/recipes/README.md

@@ -35,6 +35,7 @@ Copy-paste patterns for adding SODAX features to a React app. Each recipe is sel
 | [`staking.md`](staking.md) | `useStake`, `useUnstake`, `useClaim`, staking info, ratios |
 | [`migration.md`](migration.md) | `useMigrateIcxToSoda`, `useRevertMigrateSodaToIcx`, `useMigratebnUSD`, `useMigrateBaln` |
 | [`dex.md`](dex.md) | `useDexDeposit`, `useSupplyLiquidity`, positions, pools |
+| [`leverage-yield.md`](leverage-yield.md) | `useLeverageYieldDeposit`, `useLeverageYieldWithdraw`, `useLeverageYieldVaultSwap`, APR/position/TVL/share-balance reads |
 | [`bitcoin.md`](bitcoin.md) | `useRadfiSession`, `useFundTradingWallet`, `useRadfiWithdraw`, UTXO management |
 | [`backend-queries.md`](backend-queries.md) | Intent tracking, orderbook, money market position queries (read-only, no wallet) |
 

package/skills/sodax-dapp-kit/integration/knowledge/recipes/bitcoin.md

@@ -1,6 +1,6 @@
-# Recipe: Bitcoin (Radfi)
+# Recipe: Bitcoin (Bound Exchange)
 
-Bitcoin trading via the Radfi protocol. Authenticate, fund a trading wallet, trade, withdraw, and manage UTXOs.
+Bitcoin trading via the Bound Exchange protocol. Authenticate, fund a trading wallet, trade, withdraw, and manage UTXOs.
 
 **Depends on:** [setup.md](setup.md), [wallet-connectivity.md](wallet-connectivity.md)
 
@@ -10,7 +10,7 @@ Bitcoin trading via the Radfi protocol. Authenticate, fund a trading wallet, tra
 
 | Hook | Type | Purpose |
 |------|------|---------|
-| `useRadfiAuth` | Mutation | Authenticate with Radfi via BIP322 signing |
+| `useRadfiAuth` | Mutation | Authenticate with Bound Exchange via BIP322 signing |
 | `useRadfiSession` | Utility | Manage full session lifecycle (login, refresh, auto-refresh) |
 | `useTradingWallet` | Utility | Get trading wallet address from persisted session (synchronous) |
 
@@ -19,7 +19,7 @@ Bitcoin trading via the Radfi protocol. Authenticate, fund a trading wallet, tra
 | Hook | Type | Purpose |
 |------|------|---------|
 | `useBitcoinBalance` | Query | BTC balance for any address (sums UTXOs from mempool.space) |
-| `useTradingWalletBalance` | Query | Trading wallet balance from Radfi API (confirmed + pending) |
+| `useTradingWalletBalance` | Query | Trading wallet balance from Bound Exchange API (confirmed + pending) |
 
 ### Operations
 
@@ -32,7 +32,7 @@ Bitcoin trading via the Radfi protocol. Authenticate, fund a trading wallet, tra
 
 ## Session Flow
 
-Radfi requires authentication before any trading operation. The typical flow:
+Bound Exchange requires authentication before any trading operation. The typical flow:
 
 ```tsx
 import { useRadfiSession } from '@sodax/dapp-kit';
@@ -49,7 +49,7 @@ function BitcoinAuth() {
 
   return (
     <button onClick={login} disabled={isLoginPending}>
-      {isLoginPending ? 'Signing...' : 'Login to Radfi'}
+      {isLoginPending ? 'Signing...' : 'Login to Bound Exchange'}
     </button>
   );
 }
@@ -77,7 +77,7 @@ function BitcoinBalances({ walletAddress }: { walletAddress: string }) {
     params: { address: walletAddress },
   });
 
-  // Trading wallet balance (from Radfi API). `RadfiWalletBalance` fields:
+  // Trading wallet balance (from Bound Exchange API). `RadfiWalletBalance` fields:
   // `btcSatoshi`, `pendingSatoshi`, `externalPendingSatoshi`, `totalUtxos`.
   const { data: tradingBalance } = useTradingWalletBalance({
     params: { walletProvider, tradingAddress },
@@ -188,6 +188,6 @@ function UtxoManager({ tradingAddress }: { tradingAddress: string }) {
 
 - **Authentication required** before any trading operation. `useRadfiSession` manages this automatically.
 - **Trading wallet** is created during first authentication — not a separate step.
-- **`useTradingWallet(walletAddress)`** is a synchronous utility (no network call) — it reads the persisted Radfi session from localStorage.
+- **`useTradingWallet(walletAddress)`** is a synchronous utility (no network call) — it reads the persisted Bound Exchange session from localStorage.
 - **PSBT signing flow**: withdraw and renew operations build an unsigned PSBT server-side, user signs it locally, then submits back for co-signing and broadcast.
 - **Session tokens** are stored in localStorage keyed by wallet address. They're for API rate-limiting, not for accessing user assets.

package/skills/sodax-dapp-kit/integration/knowledge/recipes/leverage-yield.md

@@ -0,0 +1,168 @@
+# Recipe: Leverage Yield
+
+Leveraged-yield ERC-4626 vaults on Sonic. Deposit any token → `lsoda*` shares, withdraw shares → any token, and read position / APR / TVL / balances.
+
+**Depends on:** [setup.md](setup.md), [wallet-connectivity.md](wallet-connectivity.md)
+
+## Hooks
+
+### Mutations
+
+| Hook | Purpose |
+|------|---------|
+| `useLeverageYieldDeposit` | Build a deposit payload (any token → `lsoda*`) |
+| `useLeverageYieldWithdraw` | Build a withdraw payload (`lsoda*` → any token) |
+| `useLeverageYieldVaultSwap` | Execute a built payload end-to-end (create → relay → notify solver) |
+| `useSwapApprove` | Approve the spoke `inputToken` (deposit only — swap-domain hook) |
+
+### Queries
+
+| Hook | Purpose |
+|------|---------|
+| `useSwapAllowance` | Check spoke `inputToken` approval (deposit only — swap-domain hook) |
+| `useLeverageYieldEffectiveApr` | AAVE + LSD effective net APR |
+| `useLeverageYieldPosition` | Live position (collateral, debt, LTV, health factor, idle) |
+| `useLeverageYieldTotalAssets` | Vault TVL (18-dp bigint) |
+| `useLeverageYieldPreviewRedeem` | Assets for N shares (pass `1e18` for price-per-share) |
+| `useLeverageYieldShareBalances` | Per-chain share balances (array via `useQueries`) |
+
+> A deposit is a swap-style intent, so it approves the **spoke asset manager** via the swap-domain hooks — there is no leverage-yield-specific approve hook. A withdraw carries `hubWalletSwap: true` and needs no spoke approval.
+
+## Vault stats + position
+
+```tsx
+import { useLeverageYieldEffectiveApr, useLeverageYieldTotalAssets, useLeverageYieldPreviewRedeem, useLeverageYieldPosition } from '@sodax/dapp-kit';
+import type { Address } from '@sodax/sdk';
+import { formatUnits } from 'viem';
+
+const RAY = 10n ** 27n;
+
+function VaultStats({ vault }: { vault: Address }) {
+  const { data: apr } = useLeverageYieldEffectiveApr({ params: { vault } });       // 60s refresh
+  const { data: tvl } = useLeverageYieldTotalAssets({ params: { vault } });        // 60s refresh
+  const { data: position } = useLeverageYieldPosition({ params: { vault } });      // 30s refresh
+  const { data: sharePrice } = useLeverageYieldPreviewRedeem({                     // 60s refresh
+    params: { vault, shares: 10n ** 18n },
+  });
+
+  // RAY (1e27) rates → percent. effectiveNetAprRay folds the LSD staking yield in.
+  const netAprPct = apr ? Number((apr.effectiveNetAprRay * 10000n) / RAY) / 100 : undefined;
+
+  return (
+    <div>
+      {netAprPct !== undefined && <p>Net APR: {netAprPct.toFixed(2)}%</p>}
+      {tvl !== undefined && <p>TVL: {formatUnits(tvl, 18)}</p>}
+      {sharePrice !== undefined && <p>1 share = {formatUnits(sharePrice, 18)} assets</p>}
+      {position && <p>Health factor: {formatUnits(position.healthFactor, 18)}</p>}
+    </div>
+  );
+}
+```
+
+## Share balances across chains
+
+`useLeverageYieldShareBalances` returns an **array** — one query per holder. Build `holders` from the chains the user has connected, then aggregate.
+
+```tsx
+import { useLeverageYieldShareBalances } from '@sodax/dapp-kit';
+import type { Address, SpokeChainKey } from '@sodax/sdk';
+import { formatUnits } from 'viem';
+
+function ShareTotal({ vault, holders }: { vault: Address; holders: { chainKey: SpokeChainKey; address: string }[] }) {
+  const balances = useLeverageYieldShareBalances({ params: { vault, holders } }); // 15s refresh per query
+  const total = balances.reduce((acc, q) => acc + (q.data?.shares ?? 0n), 0n);
+  return <p>Total shares: {formatUnits(total, 18)}</p>;
+}
+```
+
+## Deposit (any token → `lsoda*`)
+
+Build → approve-if-needed → execute. The built payload is spread straight into `vaultSwap`.
+
+```tsx
+// @ai-snippets-skip — illustrative end-to-end flow wiring the builder, the swap-domain
+// allowance/approve hooks, and the executor across a broad walletProvider union. Real
+// call shapes per hook are in features/leverage-yield.md.
+import { useState } from 'react';
+import {
+  useLeverageYieldDeposit, useLeverageYieldVaultSwap, useSwapAllowance, useSwapApprove,
+} from '@sodax/dapp-kit';
+import { useWalletProvider } from '@sodax/wallet-sdk-react';
+import { ChainKeys, type Address, type PartnerFee } from '@sodax/sdk';
+import { parseUnits } from 'viem';
+
+const DEPOSIT_PARTNER_FEE: PartnerFee = { address: '0xYourFeeReceiver…', percentage: 100 }; // 1%
+
+function DepositForm({ vault, srcAddress, inputToken }: { vault: Address; srcAddress: string; inputToken: string }) {
+  const [amount, setAmount] = useState('');
+  const chainKey = ChainKeys.ARBITRUM_MAINNET;
+  const walletProvider = useWalletProvider({ xChainId: chainKey });
+
+  const { mutateAsyncSafe: buildDeposit } = useLeverageYieldDeposit();
+  const { mutateAsyncSafe: approve } = useSwapApprove();
+  const { mutateAsync: vaultSwap, isPending } = useLeverageYieldVaultSwap();
+
+  const handleDeposit = async () => {
+    if (!walletProvider) return;
+    const built = await buildDeposit({
+      vault, srcChainKey: chainKey, srcAddress, inputToken,
+      inputAmount: parseUnits(amount, 18),
+      minOutputAmount: 0n,             // quote via sodax.swaps.getQuote (token_dst = vault), then subtract slippage
+      partnerFee: DEPOSIT_PARTNER_FEE, // per-intent fee — must match the quote's post-fee amount
+    });
+    if (!built.ok) return;
+
+    // Deposit approves the spoke asset manager (swap-style). Gate on useSwapAllowance in render.
+    await approve({ params: built.value.params, walletProvider });
+    await vaultSwap({ ...built.value, walletProvider }); // spread the payload; lsoda* lands in the hub wallet
+  };
+
+  return (
+    <div>
+      <input value={amount} onChange={(e) => setAmount(e.target.value)} placeholder="amount" />
+      <button onClick={handleDeposit} disabled={isPending || !walletProvider}>Deposit</button>
+    </div>
+  );
+}
+```
+
+## Withdraw (`lsoda*` → any token)
+
+No approval step — `hubWalletSwap: true` authorises the share spend via a `sendMessage`.
+
+```tsx
+// @ai-snippets-skip — illustrative end-to-end flow (builder + executor) across a broad
+// walletProvider union; see features/leverage-yield.md for exact per-hook shapes.
+import { useLeverageYieldWithdraw, useLeverageYieldVaultSwap } from '@sodax/dapp-kit';
+import { useWalletProvider } from '@sodax/wallet-sdk-react';
+import { ChainKeys, type Address } from '@sodax/sdk';
+
+function WithdrawButton({ vault, srcAddress, outputToken, shares }: { vault: Address; srcAddress: string; outputToken: string; shares: bigint }) {
+  const chainKey = ChainKeys.ARBITRUM_MAINNET;
+  const walletProvider = useWalletProvider({ xChainId: chainKey });
+  const { mutateAsyncSafe: buildWithdraw } = useLeverageYieldWithdraw();
+  const { mutateAsync: vaultSwap, isPending } = useLeverageYieldVaultSwap();
+
+  const handleWithdraw = async () => {
+    if (!walletProvider) return;
+    const built = await buildWithdraw({
+      vault, srcChainKey: chainKey, srcAddress,
+      dstChainKey: chainKey, outputToken,
+      inputAmount: shares,         // lsoda* shares to burn
+      minOutputAmount: 0n,         // quote via sodax.swaps.getQuote (token_src = vault), then subtract slippage
+    });
+    if (!built.ok) return;
+    await vaultSwap({ ...built.value, walletProvider }); // built.value.hubWalletSwap === true
+  };
+
+  return <button onClick={handleWithdraw} disabled={isPending || !walletProvider}>Withdraw</button>;
+}
+```
+
+## Notes
+
+- **Two roles:** `deposit` / `withdraw` *build* a `LeverageYieldSwapPayload`; `useLeverageYieldVaultSwap` *executes* it. Always spread the built payload into the executor with a `walletProvider`.
+- **Quotes:** size `minOutputAmount` with `sodax.swaps.getQuote` — vault address as `token_dst` (deposit) or `token_src` (withdraw), since `lsoda*` shares are solver-tradeable. Subtract your slippage tolerance.
+- **Deposit fee:** a per-intent `partnerFee` is deducted from `inputAmount` before the swap; quote on the post-fee amount or the intent won't fill.
+- **Withdraw:** no spoke approval — the hub wallet authorises the share spend via `Connection.sendMessage`. Output lands at `recipient` (defaults to `srcAddress`) on `dstChainKey`.
+- **Reads** (`useLeverageYieldEffectiveApr`, `Position`, `TotalAssets`, `PreviewRedeem`) are already unwrapped — read `data` directly. `useLeverageYieldShareBalances` returns an array; aggregate the `shares` yourself.

package/skills/sodax-dapp-kit/integration/knowledge/recipes/wallet-connectivity.md

@@ -16,6 +16,9 @@ Connect wallets and pass wallet providers to feature hooks.
 | `useEstimateGas` | `@sodax/dapp-kit` | Mutation | Estimate gas for raw transactions |
 | `useStellarTrustlineCheck` | `@sodax/dapp-kit` | Query | Check if Stellar account has sufficient trustline |
 | `useRequestTrustline` | `@sodax/dapp-kit` | Mutation | Request a Stellar trustline for a token |
+| `useNearStorageCheck` | `@sodax/dapp-kit` | Query | Check if a NEAR account is NEP-141 storage-registered for a token |
+| `useRegisterNearStorage` | `@sodax/dapp-kit` | Mutation | Submit a NEP-141 `storage_deposit` so a NEAR account can receive a token |
+| `useNearStorageGate` | `@sodax/dapp-kit` | Hook | Combine the NEAR storage check, registration mutation, and UI gate flags |
 
 ## Connect a Wallet