@morpho-org/consumer-sdk 0.3.0 → 0.5.0

package/lib/entities/marketV1/marketV1.js

@@ -0,0 +1,528 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MorphoMarketV1 = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const simulation_sdk_1 = require("@morpho-org/simulation-sdk");
+const actions_1 = require("../../actions");
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+class MorphoMarketV1 {
+    client;
+    marketParams;
+    chainId;
+    constructor(client, marketParams, chainId) {
+        this.client = client;
+        this.marketParams = marketParams;
+        this.chainId = chainId;
+    }
+    async getMarketData(parameters) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        return (0, blue_sdk_viem_1.fetchMarket)(this.marketParams.id, this.client.viemClient, {
+            ...parameters,
+            chainId: this.chainId,
+            deployless: this.client.options.supportDeployless,
+        });
+    }
+    async getPositionData(userAddress, parameters) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        return (0, blue_sdk_viem_1.fetchAccrualPosition)(userAddress, this.marketParams.id, this.client.viemClient, {
+            ...parameters,
+            deployless: this.client.options.supportDeployless,
+            chainId: this.chainId,
+        });
+    }
+    supplyCollateral({ amount = 0n, userAddress, nativeAmount, }) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, userAddress);
+        if (amount < 0n) {
+            throw new types_1.NonPositiveAssetAmountError(this.marketParams.collateralToken);
+        }
+        if (nativeAmount !== undefined && nativeAmount < 0n) {
+            throw new types_1.NegativeNativeAmountError(nativeAmount);
+        }
+        const totalCollateral = amount + (nativeAmount ?? 0n);
+        if (totalCollateral === 0n) {
+            throw new types_1.ZeroCollateralAmountError(this.marketParams.id);
+        }
+        if (nativeAmount !== undefined && nativeAmount > 0n) {
+            (0, helpers_1.validateNativeCollateral)(this.chainId, this.marketParams.collateralToken);
+        }
+        return {
+            getRequirements: (params) => (0, actions_1.getRequirements)(this.client.viemClient, {
+                address: this.marketParams.collateralToken,
+                chainId: this.chainId,
+                supportSignature: this.client.options.supportSignature,
+                supportDeployless: this.client.options.supportDeployless,
+                useSimplePermit: params?.useSimplePermit,
+                args: { amount, from: userAddress },
+            }),
+            buildTx: (requirementSignature) => (0, actions_1.marketV1SupplyCollateral)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    amount,
+                    nativeAmount,
+                    onBehalf: userAddress,
+                    requirementSignature,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    borrow({ amount, userAddress, positionData, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, reallocations, }) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, userAddress);
+        if (amount <= 0n) {
+            throw new types_1.NonPositiveBorrowAmountError(this.marketParams.id);
+        }
+        (0, helpers_1.validateSlippageTolerance)(slippageTolerance);
+        if (!positionData) {
+            throw new types_1.MissingAccrualPositionError(this.marketParams.id);
+        }
+        (0, helpers_1.validateAccrualPosition)({
+            positionData,
+            expectedMarketId: this.marketParams.id,
+            expectedUser: userAddress,
+        });
+        (0, helpers_1.validatePositionHealth)({
+            positionData,
+            additionalCollateral: 0n,
+            borrowAmount: amount,
+            marketId: this.marketParams.id,
+            lltv: this.marketParams.lltv,
+        });
+        const minSharePrice = (0, helpers_1.computeMinBorrowSharePrice)({
+            borrowAmount: amount,
+            market: positionData.market,
+            slippageTolerance,
+        });
+        return {
+            getRequirements: async () => {
+                const authTx = await (0, actions_1.getMorphoAuthorizationRequirement)({
+                    viemClient: this.client.viemClient,
+                    chainId: this.chainId,
+                    userAddress,
+                });
+                return authTx ? [authTx] : [];
+            },
+            buildTx: () => (0, actions_1.marketV1Borrow)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    amount,
+                    receiver: userAddress,
+                    minSharePrice,
+                    reallocations,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    repay(params) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, params.userAddress);
+        const { userAddress, positionData, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, } = params;
+        if ("assets" in params && "shares" in params) {
+            throw new types_1.MutuallyExclusiveRepayAmountsError(this.marketParams.id);
+        }
+        const isSharesMode = "shares" in params;
+        if (isSharesMode) {
+            if (params.shares <= 0n) {
+                throw new types_1.NonPositiveRepayAmountError(this.marketParams.id);
+            }
+        }
+        else {
+            if (params.assets <= 0n) {
+                throw new types_1.NonPositiveRepayAmountError(this.marketParams.id);
+            }
+        }
+        (0, helpers_1.validateSlippageTolerance)(slippageTolerance);
+        if (!positionData) {
+            throw new types_1.MissingAccrualPositionError(this.marketParams.id);
+        }
+        (0, helpers_1.validateAccrualPosition)({
+            positionData,
+            expectedMarketId: this.marketParams.id,
+            expectedUser: userAddress,
+        });
+        let assets;
+        let shares;
+        let transferAmount;
+        if (isSharesMode) {
+            (0, helpers_1.validateRepayShares)({
+                positionData,
+                repayShares: params.shares,
+                marketId: this.marketParams.id,
+            });
+            assets = 0n;
+            shares = params.shares;
+            // Add slippage buffer to cover interest accrued between tx construction and execution.
+            // Without this, the on-chain repay amount may exceed the pre-transferred ERC20 amount.
+            const baseTransferAmount = positionData.market.toBorrowAssets(shares, "Up");
+            transferAmount = blue_sdk_1.MathLib.wMulUp(baseTransferAmount, blue_sdk_1.MathLib.WAD + slippageTolerance);
+        }
+        else {
+            (0, helpers_1.validateRepayAmount)({
+                positionData,
+                repayAssets: params.assets,
+                marketId: this.marketParams.id,
+            });
+            assets = params.assets;
+            shares = 0n;
+            transferAmount = params.assets;
+        }
+        const maxSharePrice = (0, helpers_1.computeMaxRepaySharePrice)({
+            repayAssets: assets,
+            repayShares: shares,
+            market: positionData.market,
+            slippageTolerance,
+        });
+        return {
+            getRequirements: (reqParams) => (0, actions_1.getRequirements)(this.client.viemClient, {
+                address: this.marketParams.loanToken,
+                chainId: this.chainId,
+                supportSignature: this.client.options.supportSignature,
+                supportDeployless: this.client.options.supportDeployless,
+                useSimplePermit: reqParams?.useSimplePermit,
+                args: { amount: transferAmount, from: userAddress },
+            }),
+            buildTx: (requirementSignature) => (0, actions_1.marketV1Repay)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    assets,
+                    shares,
+                    transferAmount,
+                    onBehalf: userAddress,
+                    receiver: userAddress,
+                    maxSharePrice,
+                    requirementSignature,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    withdrawCollateral({ userAddress, amount, positionData, }) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, userAddress);
+        if (amount <= 0n) {
+            throw new types_1.NonPositiveWithdrawCollateralAmountError(this.marketParams.id);
+        }
+        if (!positionData) {
+            throw new types_1.MissingAccrualPositionError(this.marketParams.id);
+        }
+        (0, helpers_1.validateAccrualPosition)({
+            positionData,
+            expectedMarketId: this.marketParams.id,
+            expectedUser: userAddress,
+        });
+        if (amount > positionData.collateral) {
+            throw new types_1.WithdrawExceedsCollateralError({
+                withdrawAmount: amount,
+                available: positionData.collateral,
+                market: positionData.marketId,
+            });
+        }
+        (0, helpers_1.validatePositionHealthAfterWithdraw)({
+            positionData,
+            withdrawAmount: amount,
+            lltv: this.marketParams.lltv,
+            marketId: this.marketParams.id,
+        });
+        return {
+            buildTx: () => (0, actions_1.marketV1WithdrawCollateral)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    amount,
+                    onBehalf: userAddress,
+                    receiver: userAddress,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    repayWithdrawCollateral(params) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, params.userAddress);
+        const { userAddress, withdrawAmount, positionData, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, } = params;
+        if ("assets" in params && "shares" in params) {
+            throw new types_1.MutuallyExclusiveRepayAmountsError(this.marketParams.id);
+        }
+        const isSharesMode = "shares" in params;
+        if (isSharesMode) {
+            if (params.shares <= 0n) {
+                throw new types_1.NonPositiveRepayAmountError(this.marketParams.id);
+            }
+        }
+        else {
+            if (params.assets <= 0n) {
+                throw new types_1.NonPositiveRepayAmountError(this.marketParams.id);
+            }
+        }
+        if (withdrawAmount <= 0n) {
+            throw new types_1.NonPositiveWithdrawCollateralAmountError(this.marketParams.id);
+        }
+        (0, helpers_1.validateSlippageTolerance)(slippageTolerance);
+        if (!positionData) {
+            throw new types_1.MissingAccrualPositionError(this.marketParams.id);
+        }
+        (0, helpers_1.validateAccrualPosition)({
+            positionData,
+            expectedMarketId: this.marketParams.id,
+            expectedUser: userAddress,
+        });
+        let assets;
+        let shares;
+        let transferAmount;
+        if (isSharesMode) {
+            (0, helpers_1.validateRepayShares)({
+                positionData,
+                repayShares: params.shares,
+                marketId: this.marketParams.id,
+            });
+            assets = 0n;
+            shares = params.shares;
+            const baseTransferAmount = positionData.market.toBorrowAssets(shares, "Up");
+            transferAmount = blue_sdk_1.MathLib.wMulUp(baseTransferAmount, blue_sdk_1.MathLib.WAD + slippageTolerance);
+        }
+        else {
+            (0, helpers_1.validateRepayAmount)({
+                positionData,
+                repayAssets: params.assets,
+                marketId: this.marketParams.id,
+            });
+            assets = params.assets;
+            shares = 0n;
+            transferAmount = params.assets;
+        }
+        if (withdrawAmount > positionData.collateral) {
+            throw new types_1.WithdrawExceedsCollateralError({
+                withdrawAmount,
+                available: positionData.collateral,
+                market: positionData.marketId,
+            });
+        }
+        // Simulate repay to get post-repay position, then validate withdraw health
+        const { position: positionAfterRepay } = positionData.repay(assets, shares);
+        (0, helpers_1.validatePositionHealthAfterWithdraw)({
+            positionData: positionAfterRepay,
+            withdrawAmount,
+            lltv: this.marketParams.lltv,
+            marketId: this.marketParams.id,
+        });
+        const maxSharePrice = (0, helpers_1.computeMaxRepaySharePrice)({
+            repayAssets: assets,
+            repayShares: shares,
+            market: positionData.market,
+            slippageTolerance,
+        });
+        return {
+            getRequirements: async (reqParams) => {
+                const [erc20Requirements, authTx] = await Promise.all([
+                    (0, actions_1.getRequirements)(this.client.viemClient, {
+                        address: this.marketParams.loanToken,
+                        chainId: this.chainId,
+                        supportSignature: this.client.options.supportSignature,
+                        supportDeployless: this.client.options.supportDeployless,
+                        useSimplePermit: reqParams?.useSimplePermit,
+                        args: { amount: transferAmount, from: userAddress },
+                    }),
+                    (0, actions_1.getMorphoAuthorizationRequirement)({
+                        viemClient: this.client.viemClient,
+                        chainId: this.chainId,
+                        userAddress,
+                    }),
+                ]);
+                return [...erc20Requirements, ...(authTx ? [authTx] : [])];
+            },
+            buildTx: (requirementSignature) => (0, actions_1.marketV1RepayWithdrawCollateral)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    assets,
+                    shares,
+                    transferAmount,
+                    withdrawAmount,
+                    onBehalf: userAddress,
+                    receiver: userAddress,
+                    maxSharePrice,
+                    requirementSignature,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    supplyCollateralBorrow({ amount = 0n, userAddress, positionData, borrowAmount, nativeAmount, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, reallocations, }) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, userAddress);
+        if (amount < 0n) {
+            throw new types_1.NonPositiveAssetAmountError(this.marketParams.collateralToken);
+        }
+        if (nativeAmount !== undefined && nativeAmount < 0n) {
+            throw new types_1.NegativeNativeAmountError(nativeAmount);
+        }
+        if (borrowAmount <= 0n) {
+            throw new types_1.NonPositiveBorrowAmountError(this.marketParams.id);
+        }
+        if (!positionData) {
+            throw new types_1.MissingAccrualPositionError(this.marketParams.id);
+        }
+        (0, helpers_1.validateAccrualPosition)({
+            positionData,
+            expectedMarketId: this.marketParams.id,
+            expectedUser: userAddress,
+        });
+        const totalCollateral = amount + (nativeAmount ?? 0n);
+        if (totalCollateral === 0n) {
+            throw new types_1.ZeroCollateralAmountError(this.marketParams.id);
+        }
+        (0, helpers_1.validateSlippageTolerance)(slippageTolerance);
+        if (nativeAmount !== undefined && nativeAmount > 0n) {
+            (0, helpers_1.validateNativeCollateral)(this.chainId, this.marketParams.collateralToken);
+        }
+        (0, helpers_1.validatePositionHealth)({
+            positionData,
+            additionalCollateral: totalCollateral,
+            borrowAmount,
+            marketId: this.marketParams.id,
+            lltv: this.marketParams.lltv,
+        });
+        const minSharePrice = (0, helpers_1.computeMinBorrowSharePrice)({
+            borrowAmount,
+            market: positionData.market,
+            slippageTolerance,
+        });
+        return {
+            getRequirements: async (params) => {
+                const [erc20Requirements, authTx] = await Promise.all([
+                    (0, actions_1.getRequirements)(this.client.viemClient, {
+                        address: this.marketParams.collateralToken,
+                        chainId: this.chainId,
+                        supportSignature: this.client.options.supportSignature,
+                        supportDeployless: this.client.options.supportDeployless,
+                        useSimplePermit: params?.useSimplePermit,
+                        args: { amount, from: userAddress },
+                    }),
+                    (0, actions_1.getMorphoAuthorizationRequirement)({
+                        viemClient: this.client.viemClient,
+                        chainId: this.chainId,
+                        userAddress,
+                    }),
+                ]);
+                return [...erc20Requirements, ...(authTx ? [authTx] : [])];
+            },
+            buildTx: (requirementSignature) => (0, actions_1.marketV1SupplyCollateralBorrow)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    amount,
+                    nativeAmount,
+                    borrowAmount,
+                    onBehalf: userAddress,
+                    receiver: userAddress,
+                    minSharePrice,
+                    requirementSignature,
+                    reallocations,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    async getReallocationData({ vaultAddresses, market, block, }) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        if (market.id !== this.marketParams.id) {
+            throw new types_1.MarketIdMismatchError(market.id, this.marketParams.id);
+        }
+        const client = this.client.viemClient;
+        const fetchParams = {
+            blockNumber: block.number,
+            chainId: this.chainId,
+            deployless: this.client.options.supportDeployless,
+        };
+        // Phase 1: Fetch all vaults in parallel to get their withdrawQueues.
+        const vaults = await Promise.all(vaultAddresses.map((addr) => (0, blue_sdk_viem_1.fetchVault)(addr, client, fetchParams)));
+        // Collect unique market IDs from all vault withdrawQueues + target market.
+        const targetMarketId = this.marketParams.id;
+        const allMarketIds = new Set([targetMarketId]);
+        const vaultMarketPairs = [];
+        for (const vault of vaults) {
+            // Always include target market pair so its config/position is fetched
+            // even when the target market is only in the vault's supplyQueue.
+            vaultMarketPairs.push({ vault: vault.address, marketId: targetMarketId });
+            for (const mid of vault.withdrawQueue) {
+                allMarketIds.add(mid);
+                if (mid !== targetMarketId) {
+                    vaultMarketPairs.push({ vault: vault.address, marketId: mid });
+                }
+            }
+        }
+        // Phase 2: Fetch all source markets, vault configs, and positions in parallel.
+        const sourceMarketIds = [...allMarketIds].filter((mid) => mid !== targetMarketId);
+        const loanToken = market.params.loanToken;
+        const [markets, configs, positions, holdings] = await Promise.all([
+            Promise.all(sourceMarketIds.map((mid) => (0, blue_sdk_viem_1.fetchMarket)(mid, client, fetchParams))),
+            Promise.all(vaultMarketPairs.map(({ vault, marketId: mid }) => (0, blue_sdk_viem_1.fetchVaultMarketConfig)(vault, mid, client, fetchParams).then((config) => ({ vault, mid, config })))),
+            Promise.all(vaultMarketPairs.map(({ vault, marketId: mid }) => (0, blue_sdk_viem_1.fetchPosition)(vault, mid, client, fetchParams).then((position) => ({
+                vault,
+                mid,
+                position,
+            })))),
+            Promise.all(vaultAddresses.map((addr) => (0, blue_sdk_viem_1.fetchHolding)(addr, loanToken, client, fetchParams))),
+        ]);
+        // Assemble records for SimulationState.
+        const marketsRecord = {
+            [targetMarketId]: market,
+        };
+        for (const m of markets) {
+            marketsRecord[m.id] = m;
+        }
+        const vaultsRecord = {};
+        for (const v of vaults) {
+            vaultsRecord[v.address] = v;
+        }
+        const vaultMarketConfigsRecord = {};
+        for (const { vault, mid, config } of configs) {
+            (vaultMarketConfigsRecord[vault] ??= {})[mid] = config;
+        }
+        const positionsRecord = {};
+        for (const { vault, mid, position } of positions) {
+            (positionsRecord[vault] ??= {})[mid] = position;
+        }
+        const holdingsRecord = {};
+        for (const holding of holdings) {
+            (holdingsRecord[holding.user] ??= {})[holding.token] = holding;
+        }
+        return new simulation_sdk_1.SimulationState({
+            chainId: this.chainId,
+            block,
+            markets: marketsRecord,
+            vaults: vaultsRecord,
+            vaultMarketConfigs: vaultMarketConfigsRecord,
+            positions: positionsRecord,
+            holdings: holdingsRecord,
+        });
+    }
+    getReallocations({ reallocationData, borrowAmount, options, }) {
+        return (0, helpers_1.computeReallocations)({
+            reallocationData,
+            marketId: this.marketParams.id,
+            borrowAmount,
+            options: { enabled: true, ...options },
+        });
+    }
+}
+exports.MorphoMarketV1 = MorphoMarketV1;

package/lib/entities/vaultV1/index.d.ts

@@ -0,0 +1 @@
+export * from "./vaultV1";

package/lib/entities/vaultV1/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./vaultV1"), exports);

package/lib/entities/vaultV1/vaultV1.d.ts

@@ -0,0 +1,95 @@
+import { type AccrualVault } from "@morpho-org/blue-sdk";
+import { fetchAccrualVault } from "@morpho-org/blue-sdk-viem";
+import { type Address } from "viem";
+import { type DepositAmountArgs, type ERC20ApprovalAction, type MorphoClientType, type Requirement, type RequirementSignature, type Transaction, type VaultV1DepositAction, type VaultV1RedeemAction, type VaultV1WithdrawAction } from "../../types";
+import type { FetchParameters } from "../../types/data";
+export interface VaultV1Actions {
+    /**
+     * Fetches the latest vault data with accrued interest.
+     *
+     * @param {FetchParameters} [parameters] - Optional fetch parameters (block number, state overrides, etc.).
+     * @returns {Promise<Awaited<ReturnType<typeof fetchAccrualVault>>>} The latest accrued vault data.
+     */
+    getData: (parameters?: FetchParameters) => Promise<Awaited<ReturnType<typeof fetchAccrualVault>>>;
+    /**
+     * Prepares a deposit into a VaultV1 (MetaMorpho) contract.
+     *
+     * Uses pre-fetched accrual vault data to compute `maxSharePrice` with slippage tolerance,
+     * then returns `buildTx` and `getRequirements` for lazy evaluation.
+     *
+     * @param {Object} params - The deposit parameters.
+     * @param {bigint} params.amount - Amount of assets to deposit.
+     * @param {Address} params.userAddress - User address initiating the deposit.
+     * @param {AccrualVault} params.accrualVault - Pre-fetched vault data with asset address and share conversion.
+     * @param {bigint} [params.slippageTolerance=DEFAULT_SLIPPAGE_TOLERANCE] - Slippage tolerance (default 0.03%, max 10%).
+     * @param {bigint} [params.nativeAmount] - Amount of native ETH to wrap into WETH. Vault asset must be wNative.
+     * @returns {Object} Object with `buildTx` and `getRequirements`.
+     */
+    deposit: (params: {
+        userAddress: Address;
+        accrualVault: AccrualVault;
+        slippageTolerance?: bigint;
+    } & DepositAmountArgs) => {
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<VaultV1DepositAction>>;
+        getRequirements: (params?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Readonly<Transaction<ERC20ApprovalAction>> | Requirement)[]>;
+    };
+    /**
+     * Prepares a withdraw from a VaultV1 (MetaMorpho) contract.
+     *
+     * @param {Object} params - The withdraw parameters.
+     * @param {bigint} params.amount - Amount of assets to withdraw.
+     * @param {Address} params.userAddress - User address initiating the withdraw.
+     * @returns {Object} Object with `buildTx`.
+     */
+    withdraw: (params: {
+        amount: bigint;
+        userAddress: Address;
+    }) => {
+        buildTx: () => Readonly<Transaction<VaultV1WithdrawAction>>;
+    };
+    /**
+     * Prepares a redeem from a VaultV1 (MetaMorpho) contract.
+     *
+     * @param {Object} params - The redeem parameters.
+     * @param {bigint} params.shares - Amount of shares to redeem.
+     * @param {Address} params.userAddress - User address initiating the redeem.
+     * @returns {Object} Object with `buildTx`.
+     */
+    redeem: (params: {
+        shares: bigint;
+        userAddress: Address;
+    }) => {
+        buildTx: () => Readonly<Transaction<VaultV1RedeemAction>>;
+    };
+}
+export declare class MorphoVaultV1 implements VaultV1Actions {
+    private readonly client;
+    private readonly vault;
+    private readonly chainId;
+    constructor(client: MorphoClientType, vault: Address, chainId: number);
+    getData(parameters?: FetchParameters): Promise<AccrualVault>;
+    deposit({ amount, userAddress, accrualVault, slippageTolerance, nativeAmount, }: {
+        userAddress: Address;
+        accrualVault: AccrualVault;
+        slippageTolerance?: bigint;
+    } & DepositAmountArgs): {
+        getRequirements: (params?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Requirement | Readonly<Transaction<ERC20ApprovalAction>>)[]>;
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<VaultV1DepositAction>>;
+    };
+    withdraw({ amount, userAddress }: {
+        amount: bigint;
+        userAddress: Address;
+    }): {
+        buildTx: () => Readonly<Transaction<VaultV1WithdrawAction>>;
+    };
+    redeem({ shares, userAddress }: {
+        shares: bigint;
+        userAddress: Address;
+    }): {
+        buildTx: () => Readonly<Transaction<VaultV1RedeemAction>>;
+    };
+}