origin-morpho-utils 0.1.0

package/dist/chunk-35AORYVF.cjs

@@ -0,0 +1,709 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+var _chunk37KGZP4Ocjs = require('./chunk-37KGZP4O.cjs');
+
+// src/abi/erc20.ts
+var erc20Abi = [
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/abi/irm-adaptive-curve.ts
+var irmAdaptiveCurveAbi = [
+  {
+    inputs: [{ name: "id", type: "bytes32" }],
+    name: "rateAtTarget",
+    outputs: [{ name: "", type: "int256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/abi/meta-morpho.ts
+var metaMorphoAbi = [
+  {
+    inputs: [],
+    name: "supplyQueueLength",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "withdrawQueueLength",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "totalAssets",
+    outputs: [{ name: "totalManagedAssets", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "", type: "uint256" }],
+    name: "supplyQueue",
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "", type: "uint256" }],
+    name: "withdrawQueue",
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "", type: "bytes32" }],
+    name: "config",
+    outputs: [
+      { name: "cap", type: "uint184" },
+      { name: "enabled", type: "bool" },
+      { name: "removableAt", type: "uint64" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/abi/morpho.ts
+var morphoAbi = [
+  {
+    inputs: [{ name: "id", type: "bytes32" }],
+    name: "market",
+    outputs: [
+      { name: "totalSupplyAssets", type: "uint128" },
+      { name: "totalSupplyShares", type: "uint128" },
+      { name: "totalBorrowAssets", type: "uint128" },
+      { name: "totalBorrowShares", type: "uint128" },
+      { name: "lastUpdate", type: "uint128" },
+      { name: "fee", type: "uint128" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "id", type: "bytes32" },
+      { name: "user", type: "address" }
+    ],
+    name: "position",
+    outputs: [
+      { name: "supplyShares", type: "uint256" },
+      { name: "borrowShares", type: "uint128" },
+      { name: "collateral", type: "uint128" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "id", type: "bytes32" }],
+    name: "idToMarketParams",
+    outputs: [
+      { name: "loanToken", type: "address" },
+      { name: "collateralToken", type: "address" },
+      { name: "oracle", type: "address" },
+      { name: "irm", type: "address" },
+      { name: "lltv", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/fetch.ts
+var _viem = require('viem');
+var ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
+async function fetchVaultMarketsViem(client, vaultAddress, morphoAddress) {
+  const vault = _viem.getAddress.call(void 0, vaultAddress);
+  const morpho = _viem.getAddress.call(void 0, morphoAddress);
+  const [supplyLen, withdrawLen, totalAssets] = await client.multicall({
+    contracts: [
+      { address: vault, abi: metaMorphoAbi, functionName: "supplyQueueLength" },
+      { address: vault, abi: metaMorphoAbi, functionName: "withdrawQueueLength" },
+      { address: vault, abi: metaMorphoAbi, functionName: "totalAssets" }
+    ],
+    allowFailure: false
+  });
+  const supplyLenN = Number(supplyLen);
+  const withdrawLenN = Number(withdrawLen);
+  if (supplyLenN === 0 && withdrawLenN === 0) return { markets: [], idleAssets: 0n };
+  const queueCalls = [
+    ...Array.from({ length: supplyLenN }, (_, i) => ({
+      address: vault,
+      abi: metaMorphoAbi,
+      functionName: "supplyQueue",
+      args: [BigInt(i)]
+    })),
+    ...Array.from({ length: withdrawLenN }, (_, i) => ({
+      address: vault,
+      abi: metaMorphoAbi,
+      functionName: "withdrawQueue",
+      args: [BigInt(i)]
+    }))
+  ];
+  const queueResults = await client.multicall({ contracts: queueCalls, allowFailure: false });
+  const supplyIds = queueResults.slice(0, supplyLenN);
+  const withdrawIds = queueResults.slice(supplyLenN);
+  const supplySet = new Set(supplyIds);
+  const withdrawSet = new Set(withdrawIds);
+  const withdrawQueueOrder = /* @__PURE__ */ new Map();
+  withdrawIds.forEach((id, i) => withdrawQueueOrder.set(id, i));
+  const allIds = [.../* @__PURE__ */ new Set([...supplyIds, ...withdrawIds])];
+  if (allIds.length === 0) return { markets: [], idleAssets: 0n };
+  const [marketStates, positions, marketParams, configs] = await Promise.all([
+    client.multicall({
+      contracts: allIds.map((id) => ({
+        address: morpho,
+        abi: morphoAbi,
+        functionName: "market",
+        args: [id]
+      })),
+      allowFailure: false
+    }),
+    client.multicall({
+      contracts: allIds.map((id) => ({
+        address: morpho,
+        abi: morphoAbi,
+        functionName: "position",
+        args: [id, vault]
+      })),
+      allowFailure: false
+    }),
+    client.multicall({
+      contracts: allIds.map((id) => ({
+        address: morpho,
+        abi: morphoAbi,
+        functionName: "idToMarketParams",
+        args: [id]
+      })),
+      allowFailure: false
+    }),
+    client.multicall({
+      contracts: allIds.map((id) => ({
+        address: vault,
+        abi: metaMorphoAbi,
+        functionName: "config",
+        args: [id]
+      })),
+      allowFailure: false
+    })
+  ]);
+  const irmAndDecimalCalls = marketParams.flatMap(
+    ([loanToken, collateralToken, , irm], i) => {
+      const hasIrm = irm && irm.toLowerCase() !== ADDRESS_ZERO;
+      const hasCollateral = collateralToken && collateralToken.toLowerCase() !== ADDRESS_ZERO;
+      const calls = [
+        hasIrm ? {
+          address: _viem.getAddress.call(void 0, irm),
+          abi: irmAdaptiveCurveAbi,
+          functionName: "rateAtTarget",
+          args: [allIds[i]]
+        } : null,
+        { address: _viem.getAddress.call(void 0, loanToken), abi: erc20Abi, functionName: "decimals" },
+        { address: _viem.getAddress.call(void 0, loanToken), abi: erc20Abi, functionName: "symbol" },
+        hasCollateral ? { address: _viem.getAddress.call(void 0, collateralToken), abi: erc20Abi, functionName: "symbol" } : null
+      ];
+      return calls.filter((c) => c !== null);
+    }
+  );
+  const irmAndDecimalResults = await client.multicall({
+    contracts: irmAndDecimalCalls,
+    allowFailure: true
+  });
+  let resultIdx = 0;
+  const ratesAtTarget = [];
+  const decimals = [];
+  const loanSymbols = [];
+  const collateralSymbols = [];
+  for (const [, collateralToken, , irm] of marketParams) {
+    const hasIrm = irm && irm.toLowerCase() !== ADDRESS_ZERO;
+    const hasCollateral = collateralToken && collateralToken.toLowerCase() !== ADDRESS_ZERO;
+    if (hasIrm) {
+      const r = irmAndDecimalResults[resultIdx++];
+      const rate = r.status === "success" ? r.result : 0n;
+      ratesAtTarget.push(rate < 0n ? 0n : rate);
+    } else {
+      ratesAtTarget.push(0n);
+    }
+    const d = irmAndDecimalResults[resultIdx++];
+    decimals.push(d.status === "success" ? Number(d.result) : 18);
+    const ls = irmAndDecimalResults[resultIdx++];
+    loanSymbols.push(ls.status === "success" ? ls.result : "???");
+    if (hasCollateral) {
+      const cs = irmAndDecimalResults[resultIdx++];
+      collateralSymbols.push(cs.status === "success" ? cs.result : "???");
+    } else {
+      collateralSymbols.push("\u2014");
+    }
+  }
+  const markets = allIds.map((marketId, i) => {
+    const [totalSupplyAssets, totalSupplyShares, totalBorrowAssets, , , fee] = marketStates[i];
+    const [supplyShares] = positions[i];
+    const [cap] = configs[i];
+    let vaultSupplyAssets = 0n;
+    if (supplyShares > 0n && totalSupplyShares > 0n) {
+      vaultSupplyAssets = supplyShares * totalSupplyAssets / totalSupplyShares;
+    }
+    const [loanToken, collateralToken] = marketParams[i];
+    return {
+      marketId,
+      name: `${collateralSymbols[i]}/${loanSymbols[i]}`,
+      loanToken,
+      collateralToken,
+      totalSupplyAssets,
+      totalBorrowAssets,
+      fee,
+      vaultSupplyAssets,
+      rateAtTarget: ratesAtTarget[i],
+      cap,
+      decimals: decimals[i],
+      inSupplyQueue: supplySet.has(marketId),
+      inWithdrawQueue: withdrawSet.has(marketId),
+      withdrawQueueIndex: _nullishCoalesce(withdrawQueueOrder.get(marketId), () => ( -1))
+    };
+  });
+  const sumVaultSupply = markets.reduce((acc, m) => acc + m.vaultSupplyAssets, 0n);
+  const idleAssets = totalAssets > sumVaultSupply ? totalAssets - sumVaultSupply : 0n;
+  return { markets, idleAssets };
+}
+async function fetchVaultApyViem(client, vaultAddress, morphoAddress, options) {
+  const { markets, idleAssets } = await fetchVaultMarketsViem(client, vaultAddress, morphoAddress);
+  if (markets.length === 0) return null;
+  const detailed = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets);
+  return { apy: detailed.apy, markets, idleAssets, marketDetails: _optionalChain([options, 'optionalAccess', _2 => _2.includeMarkets]) ? detailed.markets : [] };
+}
+
+// src/addresses.ts
+var MORPHO_BLUE_ADDRESSES = {
+  1: "0xbbbbbbbbbb9cc5e90e3b3af64bdaf62c37eeffcb",
+  // Ethereum
+  8453: "0xbbbbbbbbbb9cc5e90e3b3af64bdaf62c37eeffcb",
+  // Base
+  999: "0x68e37de8d93d3496ae143f2e900490f6280c57cd"
+  // HyperEVM
+};
+function getMorphoBlueAddress(chainId) {
+  const addr = MORPHO_BLUE_ADDRESSES[chainId];
+  if (!addr) {
+    throw new Error(
+      `No Morpho Blue address configured for chainId ${chainId}. Known chains: ${Object.keys(MORPHO_BLUE_ADDRESSES).join(", ")}`
+    );
+  }
+  return addr;
+}
+
+// src/deposit-impact.ts
+async function computeDepositImpact(client, chainId, vaultAddress, depositAmount, options) {
+  const morpho = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.morphoAddress]), () => ( getMorphoBlueAddress(chainId)));
+  const incMkts = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _4 => _4.includeMarkets]), () => ( false));
+  const result = await fetchVaultApyViem(client, vaultAddress, morpho);
+  if (!result) {
+    return { currentApy: 0, newApy: 0, impact: 0, impactBps: 0, markets: [] };
+  }
+  const { markets } = result;
+  const current = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets);
+  const sim = _chunk37KGZP4Ocjs.simulateDeposit.call(void 0, markets, depositAmount);
+  const simulated = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets, sim);
+  const impact = simulated.apy - current.apy;
+  return {
+    currentApy: current.apy,
+    newApy: simulated.apy,
+    impact,
+    impactBps: Math.round(impact * 1e4),
+    markets: incMkts ? _chunk37KGZP4Ocjs.mergeMarketDetails.call(void 0, current.markets, simulated.markets) : []
+  };
+}
+
+// src/withdrawal-impact.ts
+async function computeWithdrawalImpact(client, chainId, vaultAddress, withdrawAmount, options) {
+  const morpho = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _5 => _5.morphoAddress]), () => ( getMorphoBlueAddress(chainId)));
+  const incMkts = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _6 => _6.includeMarkets]), () => ( false));
+  const result = await fetchVaultApyViem(client, vaultAddress, morpho);
+  if (!result) {
+    return {
+      currentApy: 0,
+      newApy: 0,
+      impact: 0,
+      impactBps: 0,
+      isPartial: false,
+      withdrawableAmount: "0",
+      markets: []
+    };
+  }
+  const { markets, idleAssets } = result;
+  const current = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets);
+  const { sim, withdrawable, remaining } = _chunk37KGZP4Ocjs.simulateWithdrawal.call(void 0, markets, withdrawAmount, idleAssets);
+  const totalVaultAssets = markets.reduce((acc, m) => acc + m.vaultSupplyAssets, 0n) + idleAssets;
+  const simulated = withdrawable >= totalVaultAssets ? { apy: 0, markets: [] } : _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets, {}, sim);
+  const impact = simulated.apy - current.apy;
+  return {
+    currentApy: current.apy,
+    newApy: simulated.apy,
+    impact,
+    impactBps: Math.round(impact * 1e4),
+    isPartial: remaining > 0n,
+    withdrawableAmount: withdrawable.toString(),
+    markets: incMkts ? _chunk37KGZP4Ocjs.mergeMarketDetails.call(void 0, current.markets, simulated.markets) : []
+  };
+}
+
+// src/find-max.ts
+function defaultPrecision(markets) {
+  const decimals = markets.length > 0 ? markets[0].decimals : 18;
+  return 10n ** BigInt(decimals);
+}
+function computeMaxDepositable(markets) {
+  return markets.filter((m) => m.inSupplyQueue && m.cap > m.vaultSupplyAssets).reduce((sum, m) => sum + (m.cap - m.vaultSupplyAssets), 0n);
+}
+function computeMaxWithdrawable(markets, idleAssets) {
+  const fromMarkets = markets.filter((m) => m.inWithdrawQueue && m.withdrawQueueIndex >= 0).reduce((sum, m) => {
+    const liquidity = m.totalSupplyAssets > m.totalBorrowAssets ? m.totalSupplyAssets - m.totalBorrowAssets : 0n;
+    const available = m.vaultSupplyAssets < liquidity ? m.vaultSupplyAssets : liquidity;
+    return sum + (available > 0n ? available : 0n);
+  }, 0n);
+  return idleAssets + fromMarkets;
+}
+function buildDepositImpact(current, simulated, includeMarkets) {
+  const impact = simulated.apy - current.apy;
+  return {
+    currentApy: current.apy,
+    newApy: simulated.apy,
+    impact,
+    impactBps: Math.round(impact * 1e4),
+    markets: includeMarkets ? _chunk37KGZP4Ocjs.mergeMarketDetails.call(void 0, current.markets, simulated.markets) : []
+  };
+}
+function buildWithdrawalImpact(current, simulated, withdrawable, remaining, includeMarkets) {
+  const impact = simulated.apy - current.apy;
+  return {
+    currentApy: current.apy,
+    newApy: simulated.apy,
+    impact,
+    impactBps: Math.round(impact * 1e4),
+    isPartial: remaining > 0n,
+    withdrawableAmount: withdrawable.toString(),
+    markets: includeMarkets ? _chunk37KGZP4Ocjs.mergeMarketDetails.call(void 0, current.markets, simulated.markets) : []
+  };
+}
+function zeroDepositImpact(markets, includeMarkets) {
+  if (markets.length === 0) {
+    return { currentApy: 0, newApy: 0, impact: 0, impactBps: 0, markets: [] };
+  }
+  const current = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets);
+  return buildDepositImpact(current, current, includeMarkets);
+}
+function zeroWithdrawalImpact(markets, idleAssets, includeMarkets) {
+  if (markets.length === 0) {
+    return { currentApy: 0, newApy: 0, impact: 0, impactBps: 0, isPartial: false, withdrawableAmount: "0", markets: [] };
+  }
+  const current = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets);
+  return buildWithdrawalImpact(current, current, 0n, 0n, includeMarkets);
+}
+async function findMaxDepositAmount(markets, maxAmount, maxImpactBps, options) {
+  const raw = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.precision]), () => ( defaultPrecision(markets)));
+  const step = raw > 0n ? raw : 1n;
+  const maxImpact = maxImpactBps / 1e4;
+  const incMkts = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.includeMarkets]), () => ( false));
+  const constraint = _optionalChain([options, 'optionalAccess', _9 => _9.constraint]);
+  if (markets.length === 0 || maxAmount === 0n) {
+    return {
+      amount: 0n,
+      maxPossibleAmount: 0n,
+      isMaxAmount: maxAmount === 0n,
+      isCapped: false,
+      impact: zeroDepositImpact(markets, incMkts)
+    };
+  }
+  const maxPossible = computeMaxDepositable(markets);
+  const effectiveMax = maxAmount < maxPossible ? maxAmount : maxPossible;
+  if (effectiveMax === 0n) {
+    return {
+      amount: 0n,
+      maxPossibleAmount: maxPossible,
+      isMaxAmount: false,
+      isCapped: maxPossible === 0n,
+      impact: zeroDepositImpact(markets, incMkts)
+    };
+  }
+  const current = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets);
+  async function isAcceptable(amount) {
+    const sim2 = _chunk37KGZP4Ocjs.simulateDeposit.call(void 0, markets, amount);
+    const simulated2 = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets, sim2);
+    const impact = Math.abs(simulated2.apy - current.apy);
+    if (impact > maxImpact) return false;
+    if (!constraint) return true;
+    return constraint({
+      amount,
+      currentApy: current.apy,
+      simulatedApy: simulated2.apy,
+      impactBps: Math.round((simulated2.apy - current.apy) * 1e4),
+      markets: _chunk37KGZP4Ocjs.mergeMarketDetails.call(void 0, current.markets, simulated2.markets)
+    });
+  }
+  if (await isAcceptable(effectiveMax)) {
+    const sim2 = _chunk37KGZP4Ocjs.simulateDeposit.call(void 0, markets, effectiveMax);
+    const simulated2 = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets, sim2);
+    return {
+      amount: effectiveMax,
+      maxPossibleAmount: maxPossible,
+      isMaxAmount: effectiveMax === maxAmount,
+      isCapped: effectiveMax < maxAmount,
+      impact: buildDepositImpact(current, simulated2, incMkts)
+    };
+  }
+  if (step >= effectiveMax || !await isAcceptable(step)) {
+    return {
+      amount: 0n,
+      maxPossibleAmount: maxPossible,
+      isMaxAmount: false,
+      isCapped: false,
+      impact: zeroDepositImpact(markets, incMkts)
+    };
+  }
+  let lo = step;
+  let hi = effectiveMax;
+  while (hi - lo > step) {
+    let mid = lo + (hi - lo) / 2n;
+    mid = mid / step * step;
+    if (mid === lo) break;
+    if (await isAcceptable(mid)) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  const sim = _chunk37KGZP4Ocjs.simulateDeposit.call(void 0, markets, lo);
+  const simulated = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets, sim);
+  return {
+    amount: lo,
+    maxPossibleAmount: maxPossible,
+    isMaxAmount: false,
+    isCapped: false,
+    impact: buildDepositImpact(current, simulated, incMkts)
+  };
+}
+async function findMaxWithdrawalAmount(markets, idleAssets, maxAmount, maxImpactBps, options) {
+  const raw = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _10 => _10.precision]), () => ( defaultPrecision(markets)));
+  const step = raw > 0n ? raw : 1n;
+  const maxImpact = maxImpactBps / 1e4;
+  const incMkts = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _11 => _11.includeMarkets]), () => ( false));
+  const constraint = _optionalChain([options, 'optionalAccess', _12 => _12.constraint]);
+  if (markets.length === 0 || maxAmount === 0n) {
+    return {
+      amount: 0n,
+      maxPossibleAmount: 0n,
+      isMaxAmount: maxAmount === 0n,
+      isCapped: false,
+      impact: zeroWithdrawalImpact(markets, idleAssets, incMkts)
+    };
+  }
+  const maxPossible = computeMaxWithdrawable(markets, idleAssets);
+  const effectiveMax = maxAmount < maxPossible ? maxAmount : maxPossible;
+  if (effectiveMax === 0n) {
+    return {
+      amount: 0n,
+      maxPossibleAmount: maxPossible,
+      isMaxAmount: false,
+      isCapped: maxPossible === 0n,
+      impact: zeroWithdrawalImpact(markets, idleAssets, incMkts)
+    };
+  }
+  const current = _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets);
+  const totalVaultAssets = markets.reduce((acc, m) => acc + m.vaultSupplyAssets, 0n) + idleAssets;
+  async function isAcceptable(amount) {
+    const { sim: sim2, withdrawable: withdrawable2, remaining: remaining2 } = _chunk37KGZP4Ocjs.simulateWithdrawal.call(void 0, markets, amount, idleAssets);
+    const isFullDrain = withdrawable2 >= totalVaultAssets;
+    const simulated2 = isFullDrain ? { apy: 0, markets: [] } : _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets, {}, sim2);
+    const impact = Math.abs(simulated2.apy - current.apy);
+    if (impact > maxImpact) return false;
+    if (!constraint) return true;
+    return constraint({
+      amount,
+      currentApy: current.apy,
+      simulatedApy: simulated2.apy,
+      impactBps: Math.round((simulated2.apy - current.apy) * 1e4),
+      markets: _chunk37KGZP4Ocjs.mergeMarketDetails.call(void 0, current.markets, simulated2.markets),
+      isPartial: remaining2 > 0n,
+      withdrawableAmount: withdrawable2
+    });
+  }
+  if (effectiveMax <= idleAssets) {
+    if (!constraint || await isAcceptable(effectiveMax)) {
+      const { withdrawable: withdrawable2, remaining: remaining2 } = _chunk37KGZP4Ocjs.simulateWithdrawal.call(void 0, markets, effectiveMax, idleAssets);
+      return {
+        amount: effectiveMax,
+        maxPossibleAmount: maxPossible,
+        isMaxAmount: effectiveMax === maxAmount,
+        isCapped: effectiveMax < maxAmount,
+        impact: buildWithdrawalImpact(current, current, withdrawable2, remaining2, incMkts)
+      };
+    }
+  }
+  if (await isAcceptable(effectiveMax)) {
+    const { sim: sim2, withdrawable: withdrawable2, remaining: remaining2 } = _chunk37KGZP4Ocjs.simulateWithdrawal.call(void 0, markets, effectiveMax, idleAssets);
+    const simulated2 = withdrawable2 >= totalVaultAssets ? { apy: 0, markets: [] } : _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets, {}, sim2);
+    return {
+      amount: effectiveMax,
+      maxPossibleAmount: maxPossible,
+      isMaxAmount: effectiveMax === maxAmount,
+      isCapped: effectiveMax < maxAmount,
+      impact: buildWithdrawalImpact(current, simulated2, withdrawable2, remaining2, incMkts)
+    };
+  }
+  if (step >= effectiveMax || !await isAcceptable(step)) {
+    return {
+      amount: 0n,
+      maxPossibleAmount: maxPossible,
+      isMaxAmount: false,
+      isCapped: false,
+      impact: zeroWithdrawalImpact(markets, idleAssets, incMkts)
+    };
+  }
+  let lo = step;
+  let hi = effectiveMax;
+  while (hi - lo > step) {
+    let mid = lo + (hi - lo) / 2n;
+    mid = mid / step * step;
+    if (mid === lo) break;
+    if (await isAcceptable(mid)) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  const { sim, withdrawable, remaining } = _chunk37KGZP4Ocjs.simulateWithdrawal.call(void 0, markets, lo, idleAssets);
+  const simulated = withdrawable >= totalVaultAssets ? { apy: 0, markets: [] } : _chunk37KGZP4Ocjs.weightedVaultApyDetailed.call(void 0, markets, {}, sim);
+  return {
+    amount: lo,
+    maxPossibleAmount: maxPossible,
+    isMaxAmount: false,
+    isCapped: false,
+    impact: buildWithdrawalImpact(current, simulated, withdrawable, remaining, incMkts)
+  };
+}
+
+// src/find-max-impact.ts
+async function findMaxDeposit(client, chainId, vaultAddress, maxAmount, maxImpactBps, options) {
+  const morpho = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _13 => _13.morphoAddress]), () => ( getMorphoBlueAddress(chainId)));
+  const result = await fetchVaultApyViem(client, vaultAddress, morpho);
+  if (!result) {
+    return {
+      amount: 0n,
+      maxPossibleAmount: 0n,
+      isMaxAmount: false,
+      isCapped: false,
+      impact: { currentApy: 0, newApy: 0, impact: 0, impactBps: 0, markets: [] }
+    };
+  }
+  return findMaxDepositAmount(result.markets, maxAmount, maxImpactBps, {
+    precision: _optionalChain([options, 'optionalAccess', _14 => _14.precision]),
+    includeMarkets: _optionalChain([options, 'optionalAccess', _15 => _15.includeMarkets]),
+    constraint: _optionalChain([options, 'optionalAccess', _16 => _16.constraint])
+  });
+}
+async function findMaxWithdrawal(client, chainId, vaultAddress, maxAmount, maxImpactBps, options) {
+  const morpho = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.morphoAddress]), () => ( getMorphoBlueAddress(chainId)));
+  const result = await fetchVaultApyViem(client, vaultAddress, morpho);
+  if (!result) {
+    return {
+      amount: 0n,
+      maxPossibleAmount: 0n,
+      isMaxAmount: false,
+      isCapped: false,
+      impact: {
+        currentApy: 0,
+        newApy: 0,
+        impact: 0,
+        impactBps: 0,
+        isPartial: false,
+        withdrawableAmount: "0",
+        markets: []
+      }
+    };
+  }
+  return findMaxWithdrawalAmount(result.markets, result.idleAssets, maxAmount, maxImpactBps, {
+    precision: _optionalChain([options, 'optionalAccess', _18 => _18.precision]),
+    includeMarkets: _optionalChain([options, 'optionalAccess', _19 => _19.includeMarkets]),
+    constraint: _optionalChain([options, 'optionalAccess', _20 => _20.constraint])
+  });
+}
+
+// src/rpc.ts
+
+var MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+function makeClient(rpcUrl, chainId) {
+  return _viem.createPublicClient.call(void 0, {
+    transport: _viem.http.call(void 0, rpcUrl),
+    chain: _viem.defineChain.call(void 0, {
+      id: chainId,
+      name: `Chain ${chainId}`,
+      nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: [rpcUrl] } },
+      contracts: { multicall3: { address: MULTICALL3 } }
+    })
+  });
+}
+async function fetchVaultMarkets(rpcUrl, chainId, vaultAddress, morphoAddress) {
+  return fetchVaultMarketsViem(makeClient(rpcUrl, chainId), vaultAddress, morphoAddress);
+}
+async function fetchVaultApy(rpcUrl, chainId, vaultAddress, options) {
+  const morpho = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.morphoAddress]), () => ( getMorphoBlueAddress(chainId)));
+  return fetchVaultApyViem(makeClient(rpcUrl, chainId), vaultAddress, morpho, {
+    includeMarkets: _optionalChain([options, 'optionalAccess', _22 => _22.includeMarkets])
+  });
+}
+async function computeDepositImpactRpc(rpcUrl, chainId, vaultAddress, depositAmount, options) {
+  return computeDepositImpact(makeClient(rpcUrl, chainId), chainId, vaultAddress, depositAmount, options);
+}
+async function computeWithdrawalImpactRpc(rpcUrl, chainId, vaultAddress, withdrawAmount, options) {
+  return computeWithdrawalImpact(makeClient(rpcUrl, chainId), chainId, vaultAddress, withdrawAmount, options);
+}
+async function findMaxDepositRpc(rpcUrl, chainId, vaultAddress, maxAmount, maxImpactBps, options) {
+  return findMaxDeposit(makeClient(rpcUrl, chainId), chainId, vaultAddress, maxAmount, maxImpactBps, options);
+}
+async function findMaxWithdrawalRpc(rpcUrl, chainId, vaultAddress, maxAmount, maxImpactBps, options) {
+  return findMaxWithdrawal(makeClient(rpcUrl, chainId), chainId, vaultAddress, maxAmount, maxImpactBps, options);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.erc20Abi = erc20Abi; exports.irmAdaptiveCurveAbi = irmAdaptiveCurveAbi; exports.metaMorphoAbi = metaMorphoAbi; exports.morphoAbi = morphoAbi; exports.fetchVaultMarketsViem = fetchVaultMarketsViem; exports.fetchVaultApyViem = fetchVaultApyViem; exports.MORPHO_BLUE_ADDRESSES = MORPHO_BLUE_ADDRESSES; exports.getMorphoBlueAddress = getMorphoBlueAddress; exports.computeDepositImpact = computeDepositImpact; exports.computeWithdrawalImpact = computeWithdrawalImpact; exports.findMaxDepositAmount = findMaxDepositAmount; exports.findMaxWithdrawalAmount = findMaxWithdrawalAmount; exports.findMaxDeposit = findMaxDeposit; exports.findMaxWithdrawal = findMaxWithdrawal; exports.fetchVaultMarkets = fetchVaultMarkets; exports.fetchVaultApy = fetchVaultApy; exports.computeDepositImpactRpc = computeDepositImpactRpc; exports.computeWithdrawalImpactRpc = computeWithdrawalImpactRpc; exports.findMaxDepositRpc = findMaxDepositRpc; exports.findMaxWithdrawalRpc = findMaxWithdrawalRpc;
+//# sourceMappingURL=chunk-35AORYVF.cjs.map