@continuumdao/ctm-mpc-defi 0.2.43 → 0.2.44

package/dist/agent/skills/aave-v4/SKILL.md

@@ -38,6 +38,8 @@ Do **not** web-search Aave APRs, APYs, or reserves. Load the protocol and use th
 | Withdraw supplied balance | `ctm_aave_v4_build_withdraw_multisign` |
 | Borrow against collateral | `ctm_aave_v4_build_borrow_multisign` |
 | Repay debt | `ctm_aave_v4_build_repay_multisign` |
+| List wallet-wide Merkl claimables | `ctm_aave_v4_fetch_merkl_rewards` |
+| Claim Merkl rewards | `ctm_aave_v4_build_merkl_claim_multisign` |
 
 ## Common write inputs
 
@@ -103,6 +105,12 @@ Example: “How do Aave lending APRs compare to Compound on Ethereum?”
 2. **Borrow debt asset:** `ctm_aave_v4_build_borrow_multisign` with `underlying` = debt token (USDC), `amountHuman`, optional `collateralUnderlying` = collateral address.
 3. Explain: health factor must stay above liquidation thresholds; server may refuse or ask for risk acknowledgment.
 
+### Claim Merkl rewards
+
+1. Activate `defi:aave-v4:rewards` (or alias `aave:rewards`) after `load_defi_protocol aave-v4`.
+2. `ctm_aave_v4_fetch_merkl_rewards({ keyGenId, chainId })`.
+3. If `firstRootClaimableCount` > 0: `ctm_aave_v4_build_merkl_claim_multisign({ keyGenId, chainId })`. Repeat when `additionalRoots` > 0.
+
 ### Repay and withdraw
 
 1. **Repay:** reduce debt with repay tool (`underlying` = debt token).
@@ -154,4 +162,4 @@ After stETH is supplied:
 
 - Native supply uses wrapped native from `get_defi_protocol_supported_tokens` (`nativeWrapped`).
 - Token filter: `api_underlyings` — only API-listed underlyings are valid per chain.
-- Merkl rewards and advanced position actions are available in the node app UI, not as separate MCP tools today.
+- Wallet-wide Merkl: `ctm_aave_v4_fetch_merkl_rewards` then `ctm_aave_v4_build_merkl_claim_multisign({ keyGenId, chainId })`. Not Aave-only — other venues’ campaigns on the same distributor can appear. Server fetches proofs; do not invent `claimData`. Call again if `additionalRoots` > 0. rEUL is omitted (Euler unlock). Advanced Aave position actions besides this claim stay in the node app UI.

package/dist/agent/skills/euler-v2/SKILL.md

@@ -8,3 +8,12 @@ description: Euler v2 isolated lend/borrow, vault withdraw, and collateral opera
 Supported chains from `get_defi_protocol_supported_chains` (Euler V3 API, Goldsky `euler-simple-*` fallback). Underlyings from `get_defi_protocol_supported_tokens` (V3 EVK / Earn vaults). Isolated lend: `ctm_euler_v2_fetch_lend_vaults`. Earn vaults (curated APY): `ctm_euler_v2_fetch_earn_vaults`. Do **not** web-search Euler APYs. Copy `evaultAddress` onto build tools.
 
 Tools include isolated lend/borrow, collateral deposit/withdraw, vault withdraw, borrow repay. All `ctm_euler_v2_build_*_multisign` tools return `{ requestId }` on success (shared gas/submit section appended by the server).
+
+## Merkl rewards
+
+Activate **`defi:euler-v2:rewards`** (alias `euler:rewards` / `euler-v2:rewards`) after `load_defi_protocol euler-v2`.
+
+1. `ctm_euler_v2_fetch_merkl_rewards({ keyGenId, chainId })` — wallet-wide on that chain, not Euler-only.
+2. If `firstRootClaimableCount` > 0: `ctm_euler_v2_build_merkl_claim_multisign({ keyGenId, chainId })`. Server fetches proofs. Do not invent `claimData`. Repeat when `additionalRoots` > 0.
+
+rEUL is omitted (`skippedReulCount`). Unlock vested EUL in the node app Euler Rewards tab — there is no MCP unlock tool.

package/dist/agent/skills/morpho/SKILL.md

@@ -1,6 +1,8 @@
 # Morpho
 
-Morpho integration: **listed earn vaults** (V1 + V2, unified), **Blue** variable-rate supply/borrow, **Midnight** fixed-rate/fixed-term books, **Coinbase B20 stock-backed loans** on Base, and **Merkl** rewards.
+Morpho integration: **listed earn vaults** (V1 + V2, unified), **Lend** (Blue USDC supply + Midnight lend/offers + stock-backed books), **Blue borrow** (collateral/borrow/repay), **Midnight borrow**, **Coinbase B20 stock-backed loans** on Base, and **Merkl** rewards.
+
+Tool families after `load_defi_protocol morpho` (then `activate_tool_group` / search): `defi:morpho:vault` (Earn), `defi:morpho:lend` (lend USDC / stock-backed supply), `defi:morpho:blue` (borrow against collateral), `defi:morpho:midnight` (fixed-rate borrow), `defi:morpho:rewards`. Alias `morpho:lend` → `defi:morpho:lend`.
 
 ## Data
 
@@ -77,6 +79,8 @@ Do **not** use `ctm_arcus_build_deposit_multisign` for yield — that funds perp
 
 ## Stock-backed loans (Base)
 
+Activate **`defi:morpho:lend`** (alias `morpho:lend`) for stock-market reads plus Blue supply and Midnight lend. Borrow against stock stays on `defi:morpho:blue` / `defi:morpho:midnight`.
+
 Curators deployed isolated **Blue** (variable) and **Midnight** (fixed) markets on **Base (8453)** that take **Coinbase B20 tokenized stocks** as collateral and lend **USDC**. Morpho is the credit layer — not Aerodrome swap/LP, not Hyperliquid/Arcus trading, not Robinhood Earn (USDG on 4663).
 
 | Goal | Tool |
@@ -137,6 +141,7 @@ Server re-quotes at build time and fills `taker` / `maker` / `onBehalf` from the
 | `ctm_morpho_fetch_midnight_quote` | Quote Midnight fill |
 | `ctm_morpho_fetch_midnight_positions` | Midnight positions |
 | `ctm_morpho_fetch_midnight_offers` | Open Midnight lend offers |
+| `ctm_morpho_fetch_merkl_rewards` | Wallet-wide Merkl claimables (`keyGenId` or `user` + `chainId`) |
 | `ctm_morpho_build_vault_deposit_multisign` | Vault deposit (listed V1 or V2) |
 | `ctm_morpho_build_vault_withdraw_multisign` | Vault withdraw |
 | `ctm_morpho_build_blue_collateral_deposit_multisign` | Blue supplyCollateral |
@@ -150,7 +155,7 @@ Server re-quotes at build time and fills `taker` / `maker` / `onBehalf` from the
 | `ctm_morpho_build_midnight_cancel_lend_offer_multisign` | Cancel Midnight lend offer |
 | `ctm_morpho_build_midnight_borrow_multisign` | Midnight borrow |
 | `ctm_morpho_build_midnight_repay_multisign` | Midnight repay + withdraw |
-| `ctm_morpho_build_merkl_claim_multisign` | Merkl claim |
+| `ctm_morpho_build_merkl_claim_multisign` | Wallet-wide Merkl claim (`keyGenId` + `chainId`; server fetches proofs) |
 
 Pass `marketId` from Morpho API for Blue/Midnight tools (not recomputed on-chain).  
 **Deposits** require a **Morpho-listed** vault (`ctm_morpho_fetch_earn_vaults`). Unlisted/test vaults are rejected.
@@ -163,6 +168,7 @@ Pass `marketId` from Morpho API for Blue/Midnight tools (not recomputed on-chain
 4. Blue: `marketId` from fetch; server resolves `marketParams`. Collateral + borrow, or supply/withdraw loan token (USDC).
 5. Stock-backed on Base: `ctm_morpho_fetch_stock_markets` then the same Blue/Midnight build tools.
 6. Midnight: books → quote → lend now, lend offer (earn until filled), borrow, or cancel/repay as above.
+7. Merkl: `ctm_morpho_fetch_merkl_rewards` then `ctm_morpho_build_merkl_claim_multisign({ keyGenId, chainId })`. Wallet-wide on that chain — not Morpho-only. Do not invent `claimData`. Call again if `additionalRoots` > 0.
 
 ## Troubleshooting
 

package/dist/merklDistributor-CdqtZC9N.d.ts

@@ -0,0 +1,65 @@
+import { Address } from 'viem';
+
+declare const MERKL_API_BASE = "https://api.merkl.xyz";
+/**
+ * Canonical Merkl `Distributor.sol` on most EVM chains.
+ * https://docs.merkl.xyz/integrate-merkl/smart-contract-addresses
+ */
+declare const MERKL_DISTRIBUTOR_ADDRESS: Address;
+declare const MERKL_DISTRIBUTOR_CLAIM_GAS_FALLBACK = 500000n;
+declare const MERKL_REWARDS_NOTES = "Wallet-wide Merkl on this chain (not protocol-filtered). Other venues\u2019 campaigns can appear. Claims the first Merkle root batch; call again if additionalRoots > 0. rEUL is omitted (Euler unlock flow). Merkl updates every 8\u201312 hours.";
+type MerklDistributorClaimLeaf = {
+    root: string;
+    token: Address;
+    amountWei: bigint;
+    proofs: readonly `0x${string}`[];
+    symbol: string;
+    decimals: number;
+};
+type MerklRewardRow = {
+    symbol: string;
+    token: string;
+    amountHuman: string;
+    amountWei: string;
+    decimals: number;
+    root: string;
+};
+type MerklRewardsSummary = {
+    chainId: number;
+    user: string;
+    distributor: string;
+    claimable: MerklRewardRow[];
+    claimableCount: number;
+    firstRootClaimableCount: number;
+    additionalRoots: number;
+    skippedReulCount: number;
+    notes: string;
+};
+declare function merklUserRewardsUrl(addr: Address, chainId: number): string;
+declare function loadMerklUserRewardsJson(args: {
+    chainId: number;
+    user: Address;
+}): Promise<unknown>;
+declare function parseMerklUserRewardsToLeaves(raw: unknown, args: {
+    chainId: number;
+    user: Address;
+}): MerklDistributorClaimLeaf[];
+declare function selectFirstRootMerklLeaves(collected: readonly MerklDistributorClaimLeaf[]): MerklDistributorClaimLeaf[];
+declare function isMerklRewardEulLeaf(leaf: MerklDistributorClaimLeaf): boolean;
+/** Non-rEUL leaves on the first remaining Merkle root (one Distributor.claim tx). */
+declare function selectWalletWideMerklClaimLeaves(collected: readonly MerklDistributorClaimLeaf[]): MerklDistributorClaimLeaf[];
+declare function fetchAllMerklDistributorClaimLeaves(args: {
+    chainId: number;
+    user: Address;
+}): Promise<MerklDistributorClaimLeaf[]>;
+declare function encodeMerklDistributorClaimData(args: {
+    user: Address;
+    leaves: readonly MerklDistributorClaimLeaf[];
+}): `0x${string}`;
+declare function merklLeafToRow(leaf: MerklDistributorClaimLeaf): MerklRewardRow;
+declare function fetchMerklRewardsSummary(args: {
+    user: string;
+    chainId: number;
+}): Promise<MerklRewardsSummary>;
+
+export { MERKL_API_BASE as M, MERKL_DISTRIBUTOR_ADDRESS as a, MERKL_DISTRIBUTOR_CLAIM_GAS_FALLBACK as b, MERKL_REWARDS_NOTES as c, type MerklDistributorClaimLeaf as d, type MerklRewardRow as e, type MerklRewardsSummary as f, encodeMerklDistributorClaimData as g, fetchAllMerklDistributorClaimLeaves as h, fetchMerklRewardsSummary as i, isMerklRewardEulLeaf as j, merklUserRewardsUrl as k, loadMerklUserRewardsJson as l, merklLeafToRow as m, selectWalletWideMerklClaimLeaves as n, parseMerklUserRewardsToLeaves as p, selectFirstRootMerklLeaves as s };

package/dist/multisign-Dr0j9fHm.d.ts

@@ -0,0 +1,489 @@
+import { Address } from 'viem';
+import { b as KeyGenSubsetForPermit } from './types-lIfv59N1.js';
+
+declare const AAVE_V4_GRAPHQL_URL = "https://api.v4.aave.com/graphql";
+declare function aaveV4Gql<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
+type ChainRowV4 = {
+    chainId: number;
+    name?: string | null;
+    nativeWrappedToken?: string | null;
+};
+declare function fetchAaveV4Chains(): Promise<readonly ChainRowV4[]>;
+/**
+ * Aave v4: supported EVM chain IDs (from {@link fetchAaveV4Chains}).
+ */
+declare function loadAaveV4SupportedChainIdsFromV4Api(): Promise<ReadonlySet<number>>;
+type V4ReservesListRow = {
+    id: string;
+    onChainId?: string | null;
+    spoke?: {
+        address: string;
+        name?: string | null;
+        liquidationConfig?: {
+            targetHealthFactor: string;
+            healthFactorForMaxBonus: string;
+        } | null;
+    } | null;
+    summary: {
+        supplied: {
+            amount: {
+                value: string;
+                decimals: number;
+            };
+        };
+        borrowed: {
+            amount: {
+                value: string;
+                decimals: number;
+            };
+        };
+        suppliable: {
+            amount: {
+                value: string;
+                decimals: number;
+            };
+        };
+        supplyApy: {
+            normalized: string;
+            value: string;
+        };
+    };
+    userState: {
+        balance: {
+            amount: {
+                value: string;
+                decimals: number;
+            };
+        } | null;
+        borrowable?: {
+            amount: {
+                value: string;
+                decimals: number;
+            };
+        } | null;
+    } | null;
+};
+declare function aggregateV4SupplyDisplay(symbolForDisplay: string, rows: readonly V4ReservesListRow[]): {
+    depositedAmount: string;
+    apy: string;
+    totalDeposits: string;
+    availableLiquidity: string;
+};
+/**
+ * Formats a token notional for display: uses k (≥1k) and M (≥1M) with a few decimal places, otherwise limited decimals.
+ * Safe to reuse outside the Aave V4 dialog (e.g. tables, tooltips).
+ */
+declare function formatAaveV4TokenAmount(n: number): string;
+/**
+ * Human-readable notional for Aave v4 API decimal strings (reserve amounts, user debt, etc.).
+ * Use this for all “display from GraphQL `value`” paths so formatting stays consistent.
+ */
+declare function formatAaveV4AmountHumanFromApiString(raw: string | null | undefined): string;
+/**
+ * Unnamed reserve liquidity: supplied − borrowed (both API decimal strings, same unit).
+ */
+declare function formatAaveV4ReserveLiquidityFromSummary(args: {
+    suppliedValue: string | null | undefined;
+    borrowedValue: string | null | undefined;
+}): string;
+declare function fetchAaveV4NativeWrappedToken(chainId: number): Promise<string | null>;
+/**
+ * All underlying token addresses (lowercased checksummed form for lookup: store lowercase) listed as reserves on the chain.
+ */
+declare function fetchAaveV4SupportedUnderlyingAddressSet(chainId: number): Promise<ReadonlySet<string>>;
+declare function fetchAaveV4ReservesForUnderlying(args: {
+    chainId: number;
+    underlying: `0x${string}`;
+    user?: `0x${string}` | null;
+}): Promise<readonly V4ReservesListRow[]>;
+/**
+ * Reserve row for a hub asset on the same Aave v4 **Spoke** as the user’s collateral (same as {@link useAaveV4DepositCollateralInfo}’s `collateralForAsset`).
+ * Needed so borrow/repay multi-sign uses the same spoke as the user’s position.
+ */
+declare function pickAaveV4ReserveRowForSpoke(rows: readonly V4ReservesListRow[], spokeAddress: `0x${string}`): V4ReservesListRow | null;
+declare function aaveV4KeyForNodeAssetRow(args: {
+    contractAddress: string;
+    nativeWrapped: string | null;
+}): string | null;
+type AaveV4ChainTokenCache = {
+    supportedUnderlying: ReadonlySet<string>;
+    nativeWrapped: string | null;
+};
+/**
+ * Fetches and caches (per process) the list of Aave v4 underlying addresses on a chain and the wrapped native token.
+ */
+declare function ensureAaveV4ChainTokenCache(chainId: number): Promise<AaveV4ChainTokenCache>;
+/** UI market segment; maps to Aave v4 `Hub` by name (e.g. Plus ≈ “Main”, Core, Prime ≈ “Bluechip”). */
+type AaveV4UiMarketId = 'main' | 'core' | 'bluechip';
+type AaveV4Hub = {
+    name: string;
+    address: `0x${string}`;
+    chain: {
+        chainId: number;
+        name?: string | null;
+    };
+};
+/** `summary` is included for hub `reserves` (market borrow/supply TVL, APYs). */
+type AaveV4HubReserveSummary = {
+    supplied: {
+        amount: {
+            value: string;
+            decimals: number;
+        };
+    };
+    borrowed: {
+        amount: {
+            value: string;
+            decimals: number;
+        };
+    };
+    suppliable: {
+        amount: {
+            value: string;
+            decimals: number;
+        };
+    };
+    supplyApy: {
+        normalized: string;
+        value: string;
+    };
+    borrowApy: {
+        normalized: string;
+        value: string;
+    };
+};
+type AaveV4HubReserve = {
+    canBorrow: boolean;
+    canUseAsCollateral: boolean;
+    canSupply: boolean;
+    /** Spoke contract to call for `supply` on this reserve. */
+    spoke: {
+        address: string;
+    } | null;
+    settings: {
+        borrowable: boolean;
+        collateral: boolean;
+        collateralFactor: {
+            normalized: string;
+            value: string;
+        };
+        collateralRisk: {
+            normalized: string;
+            value: string;
+        };
+    };
+    asset: {
+        underlying: {
+            address: string;
+            info: {
+                name: string;
+                symbol: string;
+                icon: string | null;
+            } | null;
+        };
+    };
+    /** Present when using the extended hub reserves query (borrow tab, market TVL). */
+    summary?: AaveV4HubReserveSummary | null;
+};
+declare function fetchAaveV4HubsForChain(chainId: number): Promise<readonly AaveV4Hub[]>;
+/**
+ * Resolves which Aave v4 hub (Core / Plus / Prime, etc.) a UI “market” refers to.
+ * Main → Plus, Core → Core, Bluechip → Prime.
+ */
+declare function resolveAaveV4HubForUiMarket(hubs: readonly AaveV4Hub[], market: AaveV4UiMarketId, chainId: number): AaveV4Hub | null;
+/**
+ * Inverse of {@link resolveAaveV4HubForUiMarket} label mapping, for switching UI market when a hub is chosen by
+ * “first hub on chain that lists this underlying”.
+ */
+declare function aaveV4UiMarketIdForHubName(hubName: string): AaveV4UiMarketId;
+/**
+ * The selected UI market maps to a single hub, but a token may only be listed in another hub (e.g. WETH in Core, not
+ * Plus on Ethereum). Returns a hub on this chain where this underlying appears in hub reserves, so Spoke and
+ * collateral can be resolved.
+ *
+ * **When no debt hint:** `preferHub` is tried first, then other hubs in {@link aaveV4HubAutoPickTiebreakOrder} order.
+ *
+ * **When `debtUnderlying` is set (user chose a debt asset on the borrow flow):** among hubs that list **both** the
+ * **collateral** and that **debt** as borrowable, the hub with the **lowest debt borrow APY** is chosen. If
+ * `debtBorrowAmountHumanForLiquidity` is a positive number string, we **prefer** hubs where `suppliable` on the debt
+ * reserve is at least that amount; if none satisfy that, the lowest-APY hub among all debt-backed candidates is
+ * used anyway.
+ */
+declare function findAaveV4HubReserveForChainUnderlying(args: {
+    chainId: number;
+    hubs: readonly AaveV4Hub[];
+    underlying: `0x${string}`;
+    /** Tried first; if the asset is not listed here, other hubs on the same chain are scanned. */
+    preferHub: AaveV4Hub;
+    /** If set, disambiguate using this debt asset’s `borrowAPY` (and optional liquidity) per hub. */
+    debtUnderlying?: `0x${string}` | null;
+    /**
+     * When set, used with `debtUnderlying` to prefer hubs with enough `suppliable` on the debt line for a borrow
+     * of that size (human amount; commas may be included).
+     */
+    debtBorrowAmountHumanForLiquidity?: string | null;
+}): Promise<{
+    hub: AaveV4Hub;
+    hubReserves: readonly AaveV4HubReserve[];
+    reserve: AaveV4HubReserve;
+} | null>;
+declare function fetchAaveV4HubReserves(args: {
+    chainId: number;
+    hubAddress: `0x${string}`;
+}): Promise<readonly AaveV4HubReserve[]>;
+/**
+ * LTV you can borrow against a unit of this asset, e.g. "90%".
+ */
+declare function formatAaveV4PercentDisplay(normalized: string | undefined, value: string | undefined): string;
+/**
+ * Collateral / protocol risk on the same 0–100 style scale as the API, or a plain label if zero/empty.
+ */
+declare function formatAaveV4RiskDisplay(normalized: string | undefined, value: string | undefined): string;
+declare function findHubReserveForUnderlying(list: readonly AaveV4HubReserve[], underlying: `0x${string}`): AaveV4HubReserve | null;
+type AaveV4BorrowableDisplay = {
+    address: string;
+    symbol: string;
+    name: string;
+    icon: string | null;
+};
+/**
+ * De-duplicated borrowable debt assets in a hub (what users can borrow there).
+ */
+declare function borrowableAssetsFromHubReserves(rows: readonly AaveV4HubReserve[]): AaveV4BorrowableDisplay[];
+/**
+ * Current variable-debt balance per underlying token for this user in the given hub (one entry per asset).
+ * Values are API decimal strings; format with {@link formatAaveV4AmountHumanFromApiString}.
+ */
+declare function fetchAaveV4UserBorrowsDebtByUnderlyingForHub(args: {
+    user: `0x${string}`;
+    chainId: number;
+    hubAddress: `0x${string}`;
+}): Promise<ReadonlyMap<string, string>>;
+type AaveV4BorrowTableRow = {
+    address: string;
+    symbol: string;
+    name: string;
+    icon: string | null;
+    yourBorrowedDisplay: string;
+    baseBorrowApyDisplay: string;
+    totalBorrowsDisplay: string;
+    liquidityDisplay: string;
+};
+/**
+ * One row per borrowable asset in the hub, using shared human-readable formatters.
+ */
+declare function buildAaveV4BorrowTableRowsFromHub(borrowable: readonly AaveV4BorrowableDisplay[], hubReserves: readonly AaveV4HubReserve[] | null, 
+/** `undefined` = not loaded or no wallet (show em dash for “your” column). */
+debtByUnderlying: ReadonlyMap<string, string> | undefined): AaveV4BorrowTableRow[];
+
+/**
+ * `eth_estimateGas` can revert for complex Aave v4 `supply` calldata; same order of magnitude as Curve router.
+ * Exported for Get Sig / Execute fallbacks.
+ */
+declare const AAVE_V4_SPOKE_SUPPLY_DEFAULT_GAS_UNITS = 1200000n;
+declare const AAVE_V4_SPOKE_WITHDRAW_DEFAULT_GAS_UNITS = 800000n;
+declare const AAVE_V4_SPOKE_BORROW_DEFAULT_GAS_UNITS = 900000n;
+declare const AAVE_V4_SPOKE_REPAY_DEFAULT_GAS_UNITS = 1000000n;
+type ChainRow = {
+    legacy?: boolean;
+    gasLimit?: number;
+    gasMultiplier?: number;
+    gasPrice?: number;
+    baseFee?: number;
+    priorityFee?: number;
+    baseFeeMultiplier?: number;
+};
+/**
+ * Aave v4: optional WETH `deposit` (native path), exact ERC-20 `approve` to the spoke when needed, then
+ * `spoke.supply(reserveId, amount, onBehalfOf)`.
+ * Optionally appends `spoke.setUsingAsCollateral(reserveId, true, onBehalfOf)` in the same batch
+ * (same pattern as the Aave app’s “use as collateral” toggle after supply).
+ */
+declare function buildEvmMultisignBodyAaveV4DepositBatch(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: ChainRow;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    market: AaveV4UiMarketId;
+    /** Underlying to supply (e.g. WETH when user chose native, or the ERC-20). */
+    asset: Address;
+    isNativeIn: boolean;
+    /** Wrapped native; required when `isNativeIn`. */
+    nativeWrapped: Address;
+    amountHuman: string;
+    spoke: Address;
+    onBehalfOf: Address;
+    executorAddress: Address;
+    purposeText: string;
+    /**
+     * When true, add a final tx `setUsingAsCollateral(reserveId, true, onBehalfOf)` after `supply`
+     * so the new supply is enabled as borrow collateral (Aave v4 `ISpoke.setUsingAsCollateral`).
+     */
+    enableAsCollateralAfterSupply?: boolean;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+/**
+ * `Spoke.withdraw` — one transaction (same sign-request shape as a single step of a deposit batch).
+ * Prefer passing {@link fetchAaveV4SpokeReserveIdForUnderlying} result via `reserveIdOnChain` when known.
+ */
+declare function buildEvmMultisignBodyAaveV4SpokeWithdraw(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: ChainRow;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    marketLabel: string;
+    spoke: Address;
+    underlying: Address;
+    amountHuman: string;
+    onBehalfOf: Address;
+    executorAddress: Address;
+    purposeText: string;
+    /** When set, avoids an extra on-chain getReserve for the id. */
+    reserveIdOnChain?: bigint | null;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+/**
+ * `Spoke.borrow` — one transaction, same shape as {@link buildEvmMultisignBodyAaveV4SpokeWithdraw}.
+ */
+declare function buildEvmMultisignBodyAaveV4SpokeBorrow(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: ChainRow;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    marketLabel: string;
+    spoke: Address;
+    underlying: Address;
+    amountHuman: string;
+    onBehalfOf: Address;
+    executorAddress: Address;
+    purposeText: string;
+    reserveIdOnChain?: bigint | null;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+/**
+ * `approve` (if required) and `Spoke.repay` — one or two transactions (same pattern as a deposit batch).
+ */
+declare function buildEvmMultisignBodyAaveV4SpokeRepay(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: ChainRow;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    market: AaveV4UiMarketId;
+    spoke: Address;
+    underlying: Address;
+    amountHuman: string;
+    onBehalfOf: Address;
+    executorAddress: Address;
+    purposeText: string;
+    reserveIdOnChain?: bigint | null;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+/**
+ * Merkl claim-rewards call from the Aave API (`claimRewards`) — one transaction to `to` with `data` / `value`.
+ */
+declare function buildEvmMultisignBodyAaveV4MerklClaimRewards(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: ChainRow;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    to: Address;
+    data: `0x${string}`;
+    valueWei: bigint;
+    rewardIdCount: number;
+    executorAddress: Address;
+    purposeText: string;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+/**
+ * Wallet-wide Merkl `Distributor.claim` (same proofs as Morpho / Euler).
+ */
+declare function buildEvmMultisignBodyAaveV4MerklDistributorClaim(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: ChainRow;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    to: Address;
+    data: `0x${string}`;
+    valueWei: bigint;
+    claimLeafCount: number;
+    executorAddress: Address;
+    purposeText: string;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+/**
+ * Merkl `Distributor.claim` using calldata from {@link encodeMerklDistributorClaimData} / Merkl API proofs.
+ */
+declare function buildEvmMultisignBodyEulerV2MerklDistributorClaim(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: ChainRow;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    to: Address;
+    data: `0x${string}`;
+    valueWei: bigint;
+    claimLeafCount: number;
+    executorAddress: Address;
+    purposeText: string;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+/**
+ * rEUL (`RewardToken`) batched `withdrawToByLockTimestamps` → unwrap vested underlying (EUL) to `executorAddress`.
+ */
+declare function buildEvmMultisignBodyEulerV2ReulUnlock(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: ChainRow;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    to: Address;
+    data: `0x${string}`;
+    valueWei: bigint;
+    lockTimestampCount: number;
+    allowRemainderLoss: boolean;
+    executorAddress: Address;
+    purposeText: string;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+/** Minimum gas floor for Execute preflight (same style as `MIN_CURVE_ROUTER_GAS_EXEC`). */
+declare const MIN_AAVE_V4_DEPOSIT_GAS_EXEC = 400000n;
+/**
+ * True when this sign request (or `batchMeta[batchIndex]`) is an Aave v4 deposit batch step.
+ */
+declare function isAaveV4DepositEvmSignRequest(detail: Record<string, unknown> | null | undefined, batchIndex?: number): boolean;
+/**
+ * Prefer `proposalTxParams[i]` / `batchMeta[i].aaveV4.gasBuildSupply` when `eth_estimateGas` reverts.
+ */
+declare function resolveAaveV4DepositGasUnitsFromSignRequest(detail: Record<string, unknown> | null | undefined, batchIndex?: number): bigint | null;
+
+export { AAVE_V4_GRAPHQL_URL as A, fetchAaveV4HubReserves as B, fetchAaveV4HubsForChain as C, fetchAaveV4NativeWrappedToken as D, fetchAaveV4ReservesForUnderlying as E, fetchAaveV4SupportedUnderlyingAddressSet as F, fetchAaveV4UserBorrowsDebtByUnderlyingForHub as G, findAaveV4HubReserveForChainUnderlying as H, findHubReserveForUnderlying as I, formatAaveV4AmountHumanFromApiString as J, formatAaveV4PercentDisplay as K, formatAaveV4ReserveLiquidityFromSummary as L, MIN_AAVE_V4_DEPOSIT_GAS_EXEC as M, formatAaveV4RiskDisplay as N, formatAaveV4TokenAmount as O, isAaveV4DepositEvmSignRequest as P, loadAaveV4SupportedChainIdsFromV4Api as Q, pickAaveV4ReserveRowForSpoke as R, resolveAaveV4DepositGasUnitsFromSignRequest as S, resolveAaveV4HubForUiMarket as T, type V4ReservesListRow as V, AAVE_V4_SPOKE_BORROW_DEFAULT_GAS_UNITS as a, AAVE_V4_SPOKE_REPAY_DEFAULT_GAS_UNITS as b, AAVE_V4_SPOKE_SUPPLY_DEFAULT_GAS_UNITS as c, AAVE_V4_SPOKE_WITHDRAW_DEFAULT_GAS_UNITS as d, type AaveV4BorrowTableRow as e, type AaveV4BorrowableDisplay as f, type AaveV4Hub as g, type AaveV4HubReserve as h, type AaveV4HubReserveSummary as i, type AaveV4UiMarketId as j, aaveV4Gql as k, aaveV4KeyForNodeAssetRow as l, aaveV4UiMarketIdForHubName as m, aggregateV4SupplyDisplay as n, borrowableAssetsFromHubReserves as o, buildAaveV4BorrowTableRowsFromHub as p, buildEvmMultisignBodyAaveV4DepositBatch as q, buildEvmMultisignBodyAaveV4MerklClaimRewards as r, buildEvmMultisignBodyAaveV4MerklDistributorClaim as s, buildEvmMultisignBodyAaveV4SpokeBorrow as t, buildEvmMultisignBodyAaveV4SpokeRepay as u, buildEvmMultisignBodyAaveV4SpokeWithdraw as v, buildEvmMultisignBodyEulerV2MerklDistributorClaim as w, buildEvmMultisignBodyEulerV2ReulUnlock as x, ensureAaveV4ChainTokenCache as y, fetchAaveV4Chains as z };