@morpho-org/consumer-sdk 0.3.0 → 0.5.0

package/lib/entities/marketV1/marketV1.d.ts

@@ -0,0 +1,290 @@
+import { type AccrualPosition, type Market, type MarketParams } from "@morpho-org/blue-sdk";
+import { type MinimalBlock, SimulationState } from "@morpho-org/simulation-sdk";
+import type { Address } from "viem";
+import { type DepositAmountArgs, type ERC20ApprovalAction, type MarketV1BorrowAction, type MarketV1RepayAction, type MarketV1RepayWithdrawCollateralAction, type MarketV1SupplyCollateralAction, type MarketV1SupplyCollateralBorrowAction, type MarketV1WithdrawCollateralAction, type MorphoAuthorizationAction, type MorphoClientType, type ReallocationComputeOptions, type RepayAmountArgs, type Requirement, type RequirementSignature, type Transaction, type VaultReallocation } from "../../types";
+import type { FetchParameters } from "../../types/data";
+export interface MarketV1Actions {
+    /**
+     * Fetches the latest market data with accrued interest.
+     *
+     * @param parameters - Optional fetch parameters (block number, state overrides).
+     * @returns Market state including total supply/borrow assets and shares.
+     */
+    getMarketData: (parameters?: FetchParameters) => Promise<Market>;
+    /**
+     * Fetches the user's position in this market with accrued interest.
+     *
+     * @param userAddress - The user whose position to fetch.
+     * @param parameters - Optional fetch parameters (block number, state overrides).
+     * @returns Accrual position with health metrics (maxBorrowAssets, ltv, isHealthy).
+     */
+    getPositionData: (userAddress: Address, parameters?: FetchParameters) => Promise<AccrualPosition>;
+    /**
+     * Prepares a supply-collateral transaction.
+     *
+     * Routed through bundler via GeneralAdapter1.
+     * `getRequirements` returns ERC20 approval or permit for GeneralAdapter1.
+     * When `nativeAmount` is provided, native token is wrapped; collateral must be wNative.
+     *
+     * @param params - Supply collateral parameters.
+     * @returns Object with `buildTx` and `getRequirements`.
+     */
+    supplyCollateral: (params: {
+        userAddress: Address;
+    } & DepositAmountArgs) => {
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<MarketV1SupplyCollateralAction>>;
+        getRequirements: (params?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Readonly<Transaction<ERC20ApprovalAction>> | Requirement)[]>;
+    };
+    /**
+     * Prepares a borrow transaction.
+     *
+     * Routed through bundler3 via `morphoBorrow`.
+     * Validates position health with LLTV buffer (0.5%) using the pre-fetched `positionData`.
+     * Computes `minSharePrice` from market borrow state and `slippageTolerance`.
+     *
+     * When `reallocations` is provided, `reallocateTo` actions are prepended to the bundle,
+     * moving liquidity from other markets via the PublicAllocator before borrowing.
+     *
+     * `getRequirements` returns `morpho.setAuthorization(generalAdapter1, true)` if not yet authorized,
+     * since borrowing through bundler3 requires GeneralAdapter1 authorization on Morpho.
+     *
+     * **Stale `positionData` may cause unexpected health.**
+     *
+     * @param params - Borrow parameters including pre-fetched `positionData` for health validation.
+     * @returns Object with `buildTx` and `getRequirements`.
+     */
+    borrow: (params: {
+        userAddress: Address;
+        amount: bigint;
+        positionData: AccrualPosition;
+        slippageTolerance?: bigint;
+        reallocations?: readonly VaultReallocation[];
+    }) => {
+        buildTx: () => Readonly<Transaction<MarketV1BorrowAction>>;
+        getRequirements: () => Promise<Readonly<Transaction<MorphoAuthorizationAction>>[]>;
+    };
+    /**
+     * Prepares a repay transaction.
+     *
+     * Routed through bundler3 via GeneralAdapter1.
+     * Supports two modes via {@link RepayAmountArgs}:
+     * - **By assets** (`{ amount }`): repays an exact asset amount (partial repay).
+     * - **By shares** (`{ shares }`): repays exact shares (full repay, immune to interest accrual).
+     *
+     * Computes `maxSharePrice` from market borrow state and `slippageTolerance`.
+     *
+     * `getRequirements` returns ERC20 approval for loan token to GeneralAdapter1.
+     * Does NOT require Morpho authorization (anyone can repay on behalf of anyone).
+     *
+     * **Shares mode:** `slippageTolerance` also caps `transferAmount`.
+     *
+     * @param params - Repay parameters including pre-fetched `positionData`.
+     * @returns Object with `buildTx` and `getRequirements`.
+     */
+    repay: (params: {
+        userAddress: Address;
+        positionData: AccrualPosition;
+        slippageTolerance?: bigint;
+    } & RepayAmountArgs) => {
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<MarketV1RepayAction>>;
+        getRequirements: (params?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Readonly<Transaction<ERC20ApprovalAction>> | Requirement)[]>;
+    };
+    /**
+     * Prepares a withdraw-collateral transaction.
+     *
+     * Direct call to `morpho.withdrawCollateral()` — no bundler, no GeneralAdapter1.
+     * The caller (`msg.sender`) must be `onBehalf`.
+     * Validates position health after withdrawal using the LLTV buffer.
+     *
+     * No `getRequirements` — no ERC20 approval or GeneralAdapter1 authorization needed
+     * (collateral flows out of Morpho, not in).
+     *
+     * **No on-chain slippage guard — stale `positionData` risks liquidation.**
+     *
+     * @param params - Withdraw collateral parameters including pre-fetched `positionData` for health validation.
+     * @returns Object with `buildTx`.
+     */
+    withdrawCollateral: (params: {
+        userAddress: Address;
+        amount: bigint;
+        positionData: AccrualPosition;
+    }) => {
+        buildTx: () => Readonly<Transaction<MarketV1WithdrawCollateralAction>>;
+    };
+    /**
+     * Prepares an atomic repay-and-withdraw-collateral transaction.
+     *
+     * Routed through bundler3. Bundle order: repay FIRST, then withdraw.
+     * Validates combined position health: simulates the repay, then checks
+     * that the resulting position can sustain the collateral withdrawal.
+     *
+     * `getRequirements` returns in parallel:
+     * - ERC20 approval for loan token to GeneralAdapter1 (for the repay).
+     * - `morpho.setAuthorization(generalAdapter1, true)` if not yet authorized (for the withdraw).
+     *
+     * **Stale `positionData` risks underestimated debt and unsafe withdrawal.**
+     *
+     * @param params - Combined parameters including pre-fetched `positionData`.
+     * @returns Object with `buildTx` and `getRequirements`.
+     */
+    repayWithdrawCollateral: (params: {
+        userAddress: Address;
+        withdrawAmount: bigint;
+        positionData: AccrualPosition;
+        slippageTolerance?: bigint;
+    } & RepayAmountArgs) => {
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<MarketV1RepayWithdrawCollateralAction>>;
+        getRequirements: (params?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Readonly<Transaction<ERC20ApprovalAction>> | Readonly<Transaction<MorphoAuthorizationAction>> | Requirement)[]>;
+    };
+    /**
+     * Prepares an atomic supply-collateral-and-borrow transaction.
+     *
+     * Routed through the bundler. Validates position health with LLTV buffer
+     * to prevent instant liquidation on new positions near the LLTV threshold.
+     *
+     * When `reallocations` is provided, `reallocateTo` actions are prepended before
+     * `morphoBorrow` in the bundle.
+     *
+     * `getRequirements` returns in parallel:
+     * - ERC20 approval or permit for collateral token (to GeneralAdapter1).
+     * - `morpho.setAuthorization(generalAdapter1, true)` if adapter is not yet authorized.
+     *
+     * **Stale `positionData` may cause unexpected health.**
+     *
+     * @param params - Combined parameters including pre-fetched `positionData` for health validation.
+     * @returns Object with `buildTx` and `getRequirements`.
+     */
+    supplyCollateralBorrow: (params: {
+        userAddress: Address;
+        positionData: AccrualPosition;
+        borrowAmount: bigint;
+        slippageTolerance?: bigint;
+        reallocations?: readonly VaultReallocation[];
+    } & DepositAmountArgs) => {
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<MarketV1SupplyCollateralBorrowAction>>;
+        getRequirements: (params?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Readonly<Transaction<ERC20ApprovalAction>> | Readonly<Transaction<MorphoAuthorizationAction>> | Requirement)[]>;
+    };
+    /**
+     * Fetches all on-chain data needed to construct a {@link SimulationState}
+     * for computing vault reallocations via the public allocator.
+     *
+     * The returned simulation state can be passed to {@link getReallocations}
+     * to compute the `VaultReallocation[]` array for `borrow()` or
+     * `supplyCollateralBorrow()`.
+     *
+     * **Stale data reverts on-chain (fail-safe).**
+     *
+     * @param params.vaultAddresses - Addresses of MetaMorpho vaults that allocate to this market.
+     * @param params.market - The target market data (from {@link getPositionData} or {@link getMarketData}).
+     * @param params.block - The block to fetch data at (number and timestamp).
+     * @returns A SimulationState populated with all required data.
+     */
+    getReallocationData: (params: {
+        vaultAddresses: readonly Address[];
+        market: Market;
+        block: MinimalBlock;
+    }) => Promise<SimulationState>;
+    /**
+     * Computes vault reallocations for a borrow on this market.
+     *
+     * Uses the shared liquidity algorithm to determine which vaults should
+     * reallocate liquidity to this market via the PublicAllocator, based on
+     * post-borrow utilization targets.
+     *
+     * @param params.reallocationData - The current on-chain state (from {@link getReallocationData}).
+     * @param params.borrowAmount - The intended borrow amount.
+     * @param params.options - Optional reallocation computation options
+     *        (utilization targets, reallocatable vaults filter, etc.).
+     * @returns Array of vault reallocations ready to pass to `borrow()` or
+     *          `supplyCollateralBorrow()`. Empty array if no reallocation is needed.
+     */
+    getReallocations: (params: {
+        reallocationData: SimulationState;
+        borrowAmount: bigint;
+        options?: ReallocationComputeOptions;
+    }) => readonly VaultReallocation[];
+}
+export declare class MorphoMarketV1 implements MarketV1Actions {
+    private readonly client;
+    readonly marketParams: MarketParams;
+    private readonly chainId;
+    constructor(client: MorphoClientType, marketParams: MarketParams, chainId: number);
+    getMarketData(parameters?: FetchParameters): Promise<Market>;
+    getPositionData(userAddress: Address, parameters?: FetchParameters): Promise<AccrualPosition>;
+    supplyCollateral({ amount, userAddress, nativeAmount, }: {
+        userAddress: Address;
+    } & DepositAmountArgs): {
+        getRequirements: (params?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Requirement | Readonly<Transaction<ERC20ApprovalAction>>)[]>;
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<MarketV1SupplyCollateralAction>>;
+    };
+    borrow({ amount, userAddress, positionData, slippageTolerance, reallocations, }: {
+        amount: bigint;
+        userAddress: Address;
+        positionData: AccrualPosition;
+        slippageTolerance?: bigint;
+        reallocations?: readonly VaultReallocation[];
+    }): {
+        getRequirements: () => Promise<Readonly<Transaction<MorphoAuthorizationAction>>[]>;
+        buildTx: () => Readonly<Transaction<MarketV1BorrowAction>>;
+    };
+    repay(params: {
+        userAddress: Address;
+        positionData: AccrualPosition;
+        slippageTolerance?: bigint;
+    } & RepayAmountArgs): {
+        getRequirements: (reqParams?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Requirement | Readonly<Transaction<ERC20ApprovalAction>>)[]>;
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<MarketV1RepayAction>>;
+    };
+    withdrawCollateral({ userAddress, amount, positionData, }: {
+        userAddress: Address;
+        amount: bigint;
+        positionData: AccrualPosition;
+    }): {
+        buildTx: () => Readonly<Transaction<MarketV1WithdrawCollateralAction>>;
+    };
+    repayWithdrawCollateral(params: {
+        userAddress: Address;
+        withdrawAmount: bigint;
+        positionData: AccrualPosition;
+        slippageTolerance?: bigint;
+    } & RepayAmountArgs): {
+        getRequirements: (reqParams?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Requirement | Readonly<Transaction<ERC20ApprovalAction>> | Readonly<Transaction<MorphoAuthorizationAction>>)[]>;
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<MarketV1RepayWithdrawCollateralAction>>;
+    };
+    supplyCollateralBorrow({ amount, userAddress, positionData, borrowAmount, nativeAmount, slippageTolerance, reallocations, }: {
+        userAddress: Address;
+        positionData: AccrualPosition;
+        borrowAmount: bigint;
+        slippageTolerance?: bigint;
+        reallocations?: readonly VaultReallocation[];
+    } & DepositAmountArgs): {
+        getRequirements: (params?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Requirement | Readonly<Transaction<ERC20ApprovalAction>> | Readonly<Transaction<MorphoAuthorizationAction>>)[]>;
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<MarketV1SupplyCollateralBorrowAction>>;
+    };
+    getReallocationData({ vaultAddresses, market, block, }: {
+        vaultAddresses: readonly Address[];
+        market: Market;
+        block: MinimalBlock;
+    }): Promise<SimulationState>;
+    getReallocations({ reallocationData, borrowAmount, options, }: {
+        reallocationData: SimulationState;
+        borrowAmount: bigint;
+        options?: ReallocationComputeOptions;
+    }): readonly VaultReallocation[];
+}