Exit an illiquid vault in kind

import "dotenv/config";
import {
  createWalletClient,
  http,
  parseAbi,
  publicActions,
  type Address,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { mainnet } from "viem/chains";
import { morphoViemExtension } from "@morpho-org/morpho-sdk";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const client = createWalletClient({
  account,
  chain: mainnet,
  transport: http(process.env.RPC_URL),
})
  .extend(publicActions)
  .extend(morphoViemExtension({ supportSignature: true }));
const publicClient = client;

const userAddress = account.address;
const vaultV1Address = process.env.VAULT_V1_ADDRESS as Address;
const vaultV2Address = process.env.VAULT_V2_ADDRESS as Address;
const vaultReadAbi = parseAbi([
  "function balanceOf(address account) view returns (uint256)",
  "function previewRedeem(uint256 shares) view returns (uint256)",
]);

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

const vaultV2 = client.morpho.vaultV2(vaultV2Address, mainnet.id);
const [vaultV2Data, latestBlock, sharesHeld] = await Promise.all([
  vaultV2.getData(),
  publicClient.getBlock(),
  publicClient.readContract({
    address: vaultV2Address,
    abi: vaultReadAbi,
    functionName: "balanceOf",
    args: [userAddress],
  }),
]);
const maximumRedeemAssets = await publicClient.readContract({
  address: vaultV2Address,
  abi: vaultReadAbi,
  functionName: "previewRedeem",
  args: [sharesHeld],
});
// This example passes one market, so reserve the one-asset V2 rounding buffer.
const marketRoundingBuffer = 1n;
if (maximumRedeemAssets <= marketRoundingBuffer) {
  throw new Error("Vault V2 position is too small for in-kind redemption");
}
const requestedExitAssets = maximumRedeemAssets - marketRoundingBuffer;
const [marketChoice] = previewVaultV2InKindRedeem(vaultV2Data, {
  requestedExitAssets,
  timestamp: latestBlock.timestamp,
});

if (marketChoice == null) {
  throw new Error("No supported Vault V2 in-kind redemption choice");
}

console.log({
  marketParams: marketChoice.marketParams,
  maxExitAssets: marketChoice.maxExitAssets,
  exitAssets: marketChoice.exitAssets,
  remainingExitAssets: marketChoice.remainingExitAssets,
  idleAssets: marketChoice.idleAssets,
  netAssets: marketChoice.netAssets,
  feeAssets: marketChoice.feeAssets,
});
// This example executes one market choice. Rebuild from fresh state for any
// remainingExitAssets after the transaction confirms.

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

const vaultV2Exit = vaultV2.inKindRedeem({
  amount: marketChoice.exitAssets,
  marketParamsList: [marketChoice.marketParams],
  vaultData: vaultV2Data,
  userAddress,
});
const vaultV2Signatures: RequirementSignature[] = [];

// Requirements authorize only the bounded shares needed for the separately
// rounded idle, penalty, and main burns, accounting for accrual through deadline.
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);
// Simulate after authorization to check gates and post-snapshot state.
await publicClient.call({
  account: userAddress,
  to: vaultV2Tx.to,
  data: vaultV2Tx.data,
  value: vaultV2Tx.value,
});
const vaultV2Hash = await client.sendTransaction(vaultV2Tx);
await publicClient.waitForTransactionReceipt({ hash: vaultV2Hash });
console.log("Vault V2 in-kind redemption confirmed:", vaultV2Hash);

const vaultV1 = client.morpho.vaultV1(vaultV1Address, mainnet.id);
const [vaultV1Data, vaultV1SharesHeld] = await Promise.all([
  vaultV1.getData(),
  publicClient.readContract({
    address: vaultV1Address,
    abi: vaultReadAbi,
    functionName: "balanceOf",
    args: [userAddress],
  }),
]);
const vaultV1ExitAssets = await publicClient.readContract({
  address: vaultV1Address,
  abi: vaultReadAbi,
  functionName: "previewRedeem",
  args: [vaultV1SharesHeld],
});
const marketParamsList = [...vaultV1Data.allocations.values()]
  .filter(
    ({ config, position }) =>
      config.enabled && position.supplyShares > 0n,
  )
  .map(({ position }) => position.market.params);

// The allocations Map is unique by market id. Repeated entries cannot spend
// the same vault position twice.
const vaultV1Exit = vaultV1.inKindRedeem({
  amount: vaultV1ExitAssets,
  marketParamsList,
  vaultData: vaultV1Data,
  userAddress,
});

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

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);
await publicClient.call({
  account: userAddress,
  to: vaultV1Tx.to,
  data: vaultV1Tx.data,
  value: vaultV1Tx.value,
});
const vaultV1Hash = await client.sendTransaction(vaultV1Tx);
await publicClient.waitForTransactionReceipt({ hash: vaultV1Hash });
console.log("Vault V1 in-kind redemption confirmed:", vaultV1Hash);