Vault V2

import { type Address, parseUnits } from "viem";
import { mainnet } from "viem/chains";

// `client` is the extended wallet client from the Morpho SDK Setup;
// `userAddress` is its connected account.
const userAddress = USER_ADDRESS;

// chainId is mandatory (validated against the viem client).
const vault = client.morpho.vaultV2(
  "0xVaultV2Address0000000000000000000000000000" as Address,
  mainnet.id,
);

// Fetches on-chain vault state with accrued interest.
// Returns an `AccrualVaultV2` with: address, asset, totalAssets, totalSupply,
// share/asset conversion helpers (`toShares`, `toAssets`), curated allocations,
// and adapters used by `forceWithdraw` / `forceRedeem`.
const vaultData = await vault.getData();

// Routed through Bundler3 via GeneralAdapter1 - enforces `maxSharePrice`
// (ERC-4626 inflation-attack guard) and supports atomic native-token wrapping.
const deposit = vault.deposit({
  amount: parseUnits("1", 18),
  userAddress,
  vaultData,
  // slippageTolerance is a WAD-scaled bigint: 1e18 = 100%. It defaults to
  // DEFAULT_SLIPPAGE_TOLERANCE = 300000000000000n (0.03%) and is capped at 10%.
  // e.g. 0.1%: parseUnits("0.001", 18) = 1000000000000000n
  // slippageTolerance: parseUnits("0.001", 18),
});

const requirements = await deposit.getRequirements();
// e.g. [erc20Approval tx for GeneralAdapter1] OR [Permit / Permit2 signature requirement]

const depositTx = deposit.buildTx(/* [requirementSignature] */);

// For vaults whose underlying asset is the chain's wNative token (WETH on mainnet),
// you can deposit native ETH that the bundler atomically wraps before depositing.
const nativeDeposit = vault.deposit({
  nativeAmount: parseUnits("1", 18), // 1 ETH wrapped → WETH → deposited
  userAddress,
  vaultData,
});
const nativeDepositTx = nativeDeposit.buildTx();

// Mixed (ERC-20 + native) is also supported in a single bundle:
const mixedDeposit = vault.deposit({
  amount: parseUnits("0.5", 18),       // already-held WETH
  nativeAmount: parseUnits("0.5", 18), // raw ETH wrapped at execution
  userAddress,
  vaultData,
});
const mixedDepositTx = mixedDeposit.buildTx();

// Direct vault call - no bundler overhead, no Morpho authorization required.
const withdraw = vault.withdraw({
  amount: parseUnits("0.5", 18),
  userAddress,
});
const withdrawTx = withdraw.buildTx();

// Direct vault call - same as withdraw but specifies an exact share amount,
// so it is immune to share-price drift between quoting and execution.
const redeem = vault.redeem({
  shares: parseUnits("1", 18),
  userAddress,
});
const redeemTx = redeem.buildTx();

import { registerCustomAddresses } from "@morpho-org/morpho-sdk/addresses";

// A new chain entry must include the required Morpho Blue registry fields.
registerCustomAddresses({
  addresses: {
    [chainId]: {
      blue,
      bundler3: {
        bundler3,
        generalAdapter1,
      },
      adaptiveCurveIrm,
      bundles: { vaultExitBundlesV1 },
    },
  },
});

import {
  isRequirementSignature,
  type RequirementSignature,
} from "@morpho-org/morpho-sdk";

// `vaultV1Address` and `marketParamsList` are supplied by the integration.
const vaultV1 = client.morpho.vaultV1(vaultV1Address, mainnet.id);
const vaultV1Data = await vaultV1.getData();

const vaultV1Exit = vaultV1.inKindRedeem({
  amount: 1_000_000n,
  marketParamsList,
  vaultData: vaultV1Data,
  userAddress,
});

const vaultV1Signatures: RequirementSignature[] = [];
for (const requirement of await vaultV1Exit.getRequirements()) {
  if (isRequirementSignature(requirement)) {
    vaultV1Signatures.push(await requirement.sign(client, userAddress));
  } else {
    const hash = await client.sendTransaction(requirement);
    await publicClient.waitForTransactionReceipt({ hash });
  }
}

const vaultV1Tx = vaultV1Exit.buildTx(vaultV1Signatures);
// `vaultV1Tx` satisfies Readonly<Transaction<VaultV1InKindRedeemAction>>.

import {
  isRequirementSignature,
  previewVaultV2InKindRedeem,
  type RequirementSignature,
} from "@morpho-org/morpho-sdk";

const vaultV2Data = await vault.getData();
const requestedExitAssets = 1_000_000n;
const latestBlock = await publicClient.getBlock();
const marketChoices = previewVaultV2InKindRedeem(vaultV2Data, {
  requestedExitAssets,
  timestamp: latestBlock.timestamp,
});
const marketChoice = marketChoices[0];

if (marketChoice == null) {
  throw new Error("This vault has no supported in-kind redemption market");
}

// Each row is one single-market choice. It also reports `idleAssets`,
// `netAssets`, `feeAssets`, and `remainingExitAssets` for the requested amount.
const vaultV2Exit = vault.inKindRedeem({
  amount: marketChoice.exitAssets,
  marketParamsList: [marketChoice.marketParams],
  vaultData: vaultV2Data,
  userAddress,
});

const vaultV2Signatures: RequirementSignature[] = [];
for (const requirement of await vaultV2Exit.getRequirements()) {
  if (isRequirementSignature(requirement)) {
    vaultV2Signatures.push(await requirement.sign(client, userAddress));
  } else {
    const hash = await client.sendTransaction(requirement);
    await publicClient.waitForTransactionReceipt({ hash });
  }
}

const vaultV2Tx = vaultV2Exit.buildTx(vaultV2Signatures);
// `vaultV2Tx` satisfies Readonly<Transaction<VaultV2InKindRedeemAction>>.

// Encodes N `forceDeallocate` calls + 1 `withdraw` in a single VaultV2 multicall.
// Use this when the vault's idle liquidity is insufficient and you need to
// pull liquidity back from specific markets/adapters before withdrawing.
const forceWithdraw = vault.forceWithdraw({
  deallocations: [
    {
      adapter: "0xAdapter0000000000000000000000000000000000",
      amount: parseUnits("0.5", 18),
    },
  ],
  withdraw: { amount: parseUnits("0.5", 18) },
  userAddress, // penalty source AND withdraw recipient
});
const forceWithdrawTx = forceWithdraw.buildTx();

// Share-based counterpart to forceWithdraw. The deallocated total must be
// >= the asset-equivalent of the redeemed shares; apply a buffer for share-price drift.
const forceRedeem = vault.forceRedeem({
  deallocations: [
    {
      adapter: "0xAdapter0000000000000000000000000000000000",
      amount: parseUnits("1.01", 18), // small buffer over target assets
    },
  ],
  redeem: { shares: parseUnits("1", 18) },
  userAddress,
});
const forceRedeemTx = forceRedeem.buildTx();