@continuumdao/ctm-mpc-defi 0.1.4 → 0.2.0

package/dist/protocols/evm/aave-v4/index.d.ts

@@ -0,0 +1,500 @@
+import { d as ProtocolModule } from '../../../types-Ce2qNHai.js';
+import { Address } from 'viem';
+import { K as KeyGenSubsetForPermit } from '../../../keygen-DsINazx8.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[];
+
+type AaveV4SpokeOnChainReserveStatus = {
+    reserveId: bigint;
+    /** From `getReserveConfig` — not a global Spoke `paused()`. */
+    paused: boolean;
+    frozen: boolean;
+    borrowable: boolean;
+    receiveSharesEnabled: boolean;
+    collateralRisk: number;
+};
+type SpokeReadArgs = {
+    rpcUrl: string;
+    chainId: number;
+    spoke: Address;
+    underlying: Address;
+};
+/**
+ * On-chain `reserveId` for an underlying on the Spoke (`getReserve` scan). Used for
+ * `supply(uint256 reserveId, uint256 amount, address onBehalfOf)` calldata.
+ */
+declare function fetchAaveV4SpokeReserveIdForUnderlying(args: SpokeReadArgs): Promise<bigint | null>;
+/**
+ * Per-reserve pause/freeze from the Spoke (`getReserveConfig`), after resolving
+ * `reserveId` for `underlying` via `getReserve` / `getReserveCount`.
+ * Aave v4 does not expose a single contract-wide `paused()` on the Spoke for this.
+ */
+declare function fetchAaveV4SpokeReserveStatusForUnderlying(args: SpokeReadArgs): Promise<AaveV4SpokeOnChainReserveStatus | null>;
+
+/**
+ * `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;
+}>;
+/**
+ * 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;
+
+declare const AAVE_V4_PROTOCOL_ID = "aave-v4";
+declare const aaveV4ProtocolModule: ProtocolModule;
+
+export { AAVE_V4_GRAPHQL_URL, AAVE_V4_PROTOCOL_ID, AAVE_V4_SPOKE_BORROW_DEFAULT_GAS_UNITS, AAVE_V4_SPOKE_REPAY_DEFAULT_GAS_UNITS, AAVE_V4_SPOKE_SUPPLY_DEFAULT_GAS_UNITS, AAVE_V4_SPOKE_WITHDRAW_DEFAULT_GAS_UNITS, type AaveV4BorrowTableRow, type AaveV4BorrowableDisplay, type AaveV4Hub, type AaveV4HubReserve, type AaveV4HubReserveSummary, type AaveV4SpokeOnChainReserveStatus, type AaveV4UiMarketId, MIN_AAVE_V4_DEPOSIT_GAS_EXEC, type V4ReservesListRow, aaveV4Gql, aaveV4KeyForNodeAssetRow, aaveV4ProtocolModule, aaveV4UiMarketIdForHubName, aggregateV4SupplyDisplay, borrowableAssetsFromHubReserves, buildAaveV4BorrowTableRowsFromHub, buildEvmMultisignBodyAaveV4DepositBatch, buildEvmMultisignBodyAaveV4MerklClaimRewards, buildEvmMultisignBodyAaveV4SpokeBorrow, buildEvmMultisignBodyAaveV4SpokeRepay, buildEvmMultisignBodyAaveV4SpokeWithdraw, buildEvmMultisignBodyEulerV2MerklDistributorClaim, buildEvmMultisignBodyEulerV2ReulUnlock, ensureAaveV4ChainTokenCache, fetchAaveV4Chains, fetchAaveV4HubReserves, fetchAaveV4HubsForChain, fetchAaveV4NativeWrappedToken, fetchAaveV4ReservesForUnderlying, fetchAaveV4SpokeReserveIdForUnderlying, fetchAaveV4SpokeReserveStatusForUnderlying, fetchAaveV4SupportedUnderlyingAddressSet, fetchAaveV4UserBorrowsDebtByUnderlyingForHub, findAaveV4HubReserveForChainUnderlying, findHubReserveForUnderlying, formatAaveV4AmountHumanFromApiString, formatAaveV4PercentDisplay, formatAaveV4ReserveLiquidityFromSummary, formatAaveV4RiskDisplay, formatAaveV4TokenAmount, isAaveV4DepositEvmSignRequest, loadAaveV4SupportedChainIdsFromV4Api, pickAaveV4ReserveRowForSpoke, resolveAaveV4DepositGasUnitsFromSignRequest, resolveAaveV4HubForUiMarket };