Access yield on wFiat with Morpho and KPK vaults

import { parseEventLogs, parseUnits } from 'viem';
import { publicClient, walletClient } from './clients';
import { DEAD, TOKENS, VAULTS } from './constants';
import { ERC20_ABI, VAULT_ABI } from './abi';

const account = walletClient.account;
const amount = parseUnits('100000', 18); // 100,000 wARS

// 0. Safety check: the vault must hold a dead deposit, which protects new
//    depositors against share-price inflation attacks (1e9 shares for 18-decimal assets)
const deadShares = await publicClient.readContract({
  address: VAULTS.wARS,
  abi: VAULT_ABI,
  functionName: 'balanceOf',
  args: [DEAD],
});
if (deadShares < 10n ** 9n) throw new Error('Vault has no dead deposit');

// Quote shown to the user, and the minimum you accept (0.5% tolerance)
const quotedShares = await publicClient.readContract({
  address: VAULTS.wARS,
  abi: VAULT_ABI,
  functionName: 'previewDeposit',
  args: [amount],
});
const minShares = (quotedShares * 9950n) / 10000n;

// 1. Approve the vault to pull exactly this amount
const allowance = await publicClient.readContract({
  address: TOKENS.wARS,
  abi: ERC20_ABI,
  functionName: 'allowance',
  args: [account.address, VAULTS.wARS],
});
if (allowance < amount) {
  const approveHash = await walletClient.writeContract({
    address: TOKENS.wARS,
    abi: ERC20_ABI,
    functionName: 'approve',
    args: [VAULTS.wARS, amount],
  });
  await publicClient.waitForTransactionReceipt({ hash: approveHash });
}

// 2. Simulate first: catches reverts (for example, insufficient balance or allowance)
const { request, result: expectedShares } = await publicClient.simulateContract({
  account,
  address: VAULTS.wARS,
  abi: VAULT_ABI,
  functionName: 'deposit',
  args: [amount, account.address], // assets, receiver
});
if (expectedShares < minShares) throw new Error('Share price moved beyond tolerance');

// 3. Deposit, then record the shares actually minted, read from the receipt
const depositHash = await walletClient.writeContract(request);
const receipt = await publicClient.waitForTransactionReceipt({ hash: depositHash });
const [deposit] = parseEventLogs({
  abi: VAULT_ABI,
  eventName: 'Deposit',
  logs: receipt.logs.filter((log) => log.address.toLowerCase() === VAULTS.wARS.toLowerCase()),
});
console.log('Shares minted:', deposit.args.shares);

import { publicClient, walletClient } from './clients';
import { VAULTS } from './constants';
import { VAULT_ABI } from './abi';

const account = walletClient.account;

export const shares = await publicClient.readContract({
  address: VAULTS.wARS,
  abi: VAULT_ABI,
  functionName: 'balanceOf',
  args: [account.address],
});

// Current value of the position in wARS
const assets = await publicClient.readContract({
  address: VAULTS.wARS,
  abi: VAULT_ABI,
  functionName: 'convertToAssets',
  args: [shares],
});

import { parseEventLogs, zeroAddress } from 'viem';
import { publicClient, walletClient } from './clients';
import { TOKENS, VAULTS } from './constants';
import { ERC20_ABI, VAULT_ABI } from './abi';
import { shares } from './position';

const account = walletClient.account;

// Liquidity for immediate withdrawals = idle wFiat + what the liquidity adapter can return.
// Neither KPK vault sets a liquidity adapter today, so idle is all of it. If one is set,
// read `liquidity` from the Morpho API instead.
const [idle, liquidityAdapter, expectedAssets] = await Promise.all([
  publicClient.readContract({
    address: TOKENS.wARS,
    abi: ERC20_ABI,
    functionName: 'balanceOf',
    args: [VAULTS.wARS],
  }),
  publicClient.readContract({
    address: VAULTS.wARS,
    abi: VAULT_ABI,
    functionName: 'liquidityAdapter',
  }),
  publicClient.readContract({
    address: VAULTS.wARS,
    abi: VAULT_ABI,
    functionName: 'previewRedeem',
    args: [shares],
  }),
]);
if (liquidityAdapter === zeroAddress && expectedAssets > idle) {
  // Not enough liquidity for a regular withdrawal: offer forceDeallocate (see below)
  // or a partial withdrawal instead of sending a transaction that reverts
  throw new Error('Not enough idle liquidity for a regular withdrawal');
}

// Full exit: burn all shares, send wARS to the user
const { request } = await publicClient.simulateContract({
  account,
  address: VAULTS.wARS,
  abi: VAULT_ABI,
  functionName: 'redeem',
  args: [shares, account.address, account.address], // shares, receiver, owner
});
const redeemHash = await walletClient.writeContract(request);
const receipt = await publicClient.waitForTransactionReceipt({ hash: redeemHash });
const [withdrawal] = parseEventLogs({
  abi: VAULT_ABI,
  eventName: 'Withdraw',
  logs: receipt.logs.filter((log) => log.address.toLowerCase() === VAULTS.wARS.toLowerCase()),
});
console.log('wARS received:', withdrawal.args.assets);