fix: bugs

Author: shahthepro

docs/algorithm.md

@@ -426,15 +426,52 @@ function computeWithdrawalImpact(markets, idleAssets, withdrawAmount):
     currentApy = weightedVaultApy(markets)
     { sim, withdrawable, remaining } = simulateWithdrawal(markets, withdrawAmount, idleAssets)
 
-    totalVaultAssets = sum(m.vaultSupplyAssets for m in markets) + idleAssets
-
-    if withdrawable >= totalVaultAssets:
-        newApy = 0
-    else:
-        newApy = weightedVaultApy(markets, withdrawalSim=sim)
+    newApy = weightedVaultApy(markets, withdrawalSim=sim)
+    // Full drain: all vault weights become 0 → weightedVaultApy returns 0 naturally
 
     impact = newApy - currentApy
     impactBps = round(impact * 10000)
     isPartial = remaining > 0
     return { currentApy, newApy, impact, impactBps, isPartial, withdrawableAmount: withdrawable }
 ```
+
+## 8. Interest Accrual
+
+Morpho Blue accrues interest lazily — `totalSupplyAssets` and `totalBorrowAssets` are only updated on-chain when someone interacts with the market. The `market()` view function returns stored (potentially stale) state.
+
+When fetching market data, the library computes accrued interest locally to correct for staleness:
+
+```pseudocode
+function accrueMarketInterest(market, now):
+    elapsed = now - market.lastUpdate
+    if elapsed <= 0 or market.totalBorrowAssets == 0:
+        return unchanged
+
+    borrowRate = computeBorrowRate(market.rateAtTarget, market.totalSupplyAssets, market.totalBorrowAssets)
+    interest = market.totalBorrowAssets * taylorCompounded(borrowRate, elapsed) / WAD
+    feeAmount = interest * market.fee / WAD
+
+    market.totalBorrowAssets += interest
+    market.totalSupplyAssets += interest
+    market.totalSupplyShares += feeAmount * market.totalSupplyShares / (market.totalSupplyAssets - feeAmount)
+```
+
+Where `taylorCompounded(rate, n)` is a 3rd-order Taylor approximation of `exp(rate * n) - 1`, matching the on-chain implementation.
+
+## 9. Limitations
+
+### 9.1 Point-in-Time rateAtTarget
+
+The Morpho Blue IRM is adaptive: `rateAtTarget` drifts over time based on utilization history. When utilization is above the 90% target, `rateAtTarget` increases; when below, it decreases. The adjustment speed is approximately 50x/year.
+
+All simulations in this library use the **current** `rateAtTarget` value. A large deposit that pushes utilization well below target would, over time, cause `rateAtTarget` to decrease further, compounding the APY reduction beyond the point-in-time estimate. Conversely, a large withdrawal pushing utilization above target would cause `rateAtTarget` to increase.
+
+For small deposits/withdrawals relative to market size, this drift is negligible. For large position changes, the true long-term impact will differ from the instantaneous estimate.
+
+### 9.2 Floating-Point Precision
+
+See section 1.1 for details on numerical precision. The library uses JavaScript `number` (IEEE-754 double) for APY math after converting on-chain `bigint` values. This is sufficient for all practical vault sizes but loses precision for raw balances exceeding `2^53` base units.
+
+### 9.3 Continuous Compounding Approximation
+
+The library uses `exp(rate * time) - 1` for APY computation, while Morpho on-chain uses a 3rd-order Taylor approximation. Both approximate continuous compounding and differ by less than `10^-8` for realistic rates.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "origin-morpho-utils",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Morpho Blue / MetaMorpho vault APY computation and deposit/withdrawal impact simulation",
   "license": "BUSL-1.1",
   "author": "Origin Protocol",

src/fetch.ts

@@ -13,6 +13,61 @@ import type { MarketForApy, VaultApyResult, VaultFetchResult } from './types.js'
 
 const ADDRESS_ZERO = '0x0000000000000000000000000000000000000000'
 
+// --- Interest accrual helpers (matches Morpho Blue on-chain logic) ---
+
+const WAD_BI = 10n ** 18n
+const TARGET_UTIL_WAD = (9n * WAD_BI) / 10n // 0.9e18
+const STEEPNESS_WAD = 4n * WAD_BI // 4e18
+
+function computeBorrowRateWad(rateAtTarget: bigint, totalSupply: bigint, totalBorrow: bigint): bigint {
+  if (totalSupply === 0n || rateAtTarget <= 0n) return 0n
+  const util = (totalBorrow * WAD_BI) / totalSupply
+  const err =
+    util > TARGET_UTIL_WAD
+      ? ((util - TARGET_UTIL_WAD) * WAD_BI) / (WAD_BI - TARGET_UTIL_WAD)
+      : ((util - TARGET_UTIL_WAD) * WAD_BI) / TARGET_UTIL_WAD
+  const coeff = err < 0n ? WAD_BI - (WAD_BI * WAD_BI) / STEEPNESS_WAD : STEEPNESS_WAD - WAD_BI
+  return (((coeff * err) / WAD_BI + WAD_BI) * rateAtTarget) / WAD_BI
+}
+
+function wTaylorCompounded(rate: bigint, elapsed: bigint): bigint {
+  const firstTerm = rate * elapsed
+  const secondTerm = (firstTerm * firstTerm) / (2n * WAD_BI)
+  const thirdTerm = (secondTerm * firstTerm) / (3n * WAD_BI)
+  return firstTerm + secondTerm + thirdTerm
+}
+
+function accrueMarketInterest(
+  totalSupplyAssets: bigint,
+  totalSupplyShares: bigint,
+  totalBorrowAssets: bigint,
+  fee: bigint,
+  rateAtTarget: bigint,
+  lastUpdate: bigint,
+  now: bigint,
+): { totalSupplyAssets: bigint; totalBorrowAssets: bigint; totalSupplyShares: bigint } {
+  const elapsed = now - lastUpdate
+  if (elapsed <= 0n || totalBorrowAssets === 0n) {
+    return { totalSupplyAssets, totalBorrowAssets, totalSupplyShares }
+  }
+  const borrowRate = computeBorrowRateWad(rateAtTarget, totalSupplyAssets, totalBorrowAssets)
+  if (borrowRate <= 0n) {
+    return { totalSupplyAssets, totalBorrowAssets, totalSupplyShares }
+  }
+  const interest = (totalBorrowAssets * wTaylorCompounded(borrowRate, elapsed)) / WAD_BI
+  if (interest === 0n) {
+    return { totalSupplyAssets, totalBorrowAssets, totalSupplyShares }
+  }
+  const feeAmount = (interest * fee) / WAD_BI
+  const newBorrow = totalBorrowAssets + interest
+  const newSupply = totalSupplyAssets + interest
+  let newShares = totalSupplyShares
+  if (feeAmount > 0n && newSupply > feeAmount) {
+    newShares += (feeAmount * totalSupplyShares) / (newSupply - feeAmount)
+  }
+  return { totalSupplyAssets: newSupply, totalBorrowAssets: newBorrow, totalSupplyShares: newShares }
+}
+
 /**
  * Fetch all market data for a MetaMorpho vault using viem multicall.
  *
@@ -172,15 +227,27 @@ export async function fetchVaultMarketsViem(
     }
   }
 
-  // 6. Assemble
+  // 6. Assemble (with interest accrual to correct stale on-chain state)
+  const now = BigInt(Math.floor(Date.now() / 1000))
   const markets: MarketForApy[] = allIds.map((marketId, i) => {
-    const [totalSupplyAssets, totalSupplyShares, totalBorrowAssets, , , fee] = marketStates[i]
+    const [rawSupplyAssets, rawSupplyShares, rawBorrowAssets, , lastUpdate, fee] = marketStates[i]
     const [supplyShares] = positions[i]
     const [cap] = configs[i]
 
+    // Accrue interest since lastUpdate to get true current state
+    const accrued = accrueMarketInterest(
+      rawSupplyAssets,
+      rawSupplyShares,
+      rawBorrowAssets,
+      fee,
+      ratesAtTarget[i],
+      lastUpdate,
+      now,
+    )
+
     let vaultSupplyAssets = 0n
-    if (supplyShares > 0n && totalSupplyShares > 0n) {
-      vaultSupplyAssets = (supplyShares * totalSupplyAssets) / totalSupplyShares
+    if (supplyShares > 0n && accrued.totalSupplyShares > 0n) {
+      vaultSupplyAssets = (supplyShares * accrued.totalSupplyAssets) / accrued.totalSupplyShares
     }
 
     const [loanToken, collateralToken] = marketParams[i] as unknown as [string, string, string, string, bigint]
@@ -190,8 +257,8 @@ export async function fetchVaultMarketsViem(
       name: `${collateralSymbols[i]}/${loanSymbols[i]}`,
       loanToken,
       collateralToken,
-      totalSupplyAssets,
-      totalBorrowAssets,
+      totalSupplyAssets: accrued.totalSupplyAssets,
+      totalBorrowAssets: accrued.totalBorrowAssets,
       fee,
       vaultSupplyAssets,
       rateAtTarget: ratesAtTarget[i],

src/find-max.ts

@@ -69,21 +69,6 @@ function buildWithdrawalImpact(
   }
 }
 
-function makeFullDrainSnapshot(current: VaultApyDetailed): VaultApyDetailed {
-  return {
-    apy: 0,
-    markets: current.markets.map((m) => ({
-      marketId: m.marketId,
-      name: m.name,
-      supplyApy: 0,
-      borrowApy: 0,
-      utilization: 0,
-      allocationPct: 0,
-      vaultSupplyAssets: 0n,
-    })),
-  }
-}
-
 function zeroDepositImpact(markets: MarketForApy[], includeMarkets: boolean): DepositImpactResult {
   if (markets.length === 0) {
     return { currentApy: 0, newApy: 0, impact: 0, impactBps: 0, markets: [] }
@@ -92,11 +77,7 @@ function zeroDepositImpact(markets: MarketForApy[], includeMarkets: boolean): De
   return buildDepositImpact(current, current, includeMarkets)
 }
 
-function zeroWithdrawalImpact(
-  markets: MarketForApy[],
-  idleAssets: bigint,
-  includeMarkets: boolean,
-): WithdrawalImpactResult {
+function zeroWithdrawalImpact(markets: MarketForApy[], includeMarkets: boolean): WithdrawalImpactResult {
   if (markets.length === 0) {
     return { currentApy: 0, newApy: 0, impact: 0, impactBps: 0, isPartial: false, withdrawableAmount: '0', markets: [] }
   }
@@ -207,6 +188,13 @@ export async function findMaxDepositAmount(
     }
   }
 
+  if (constraint && lo + step <= effectiveMax && (await isAcceptable(lo + step))) {
+    console.warn(
+      '[morpho-apy] findMaxDepositAmount: constraint may not be monotonic — ' +
+        'amount above the binary search result still passes. Results may be inaccurate.',
+    )
+  }
+
   const sim = simulateDeposit(markets, lo)
   const simulated = weightedVaultApyDetailed(markets, sim)
   return {
@@ -248,7 +236,7 @@ export async function findMaxWithdrawalAmount(
       maxPossibleAmount: 0n,
       isMaxAmount: maxAmount === 0n,
       isCapped: false,
-      impact: zeroWithdrawalImpact(markets, idleAssets, incMkts),
+      impact: zeroWithdrawalImpact(markets, incMkts),
     }
   }
 
@@ -261,18 +249,16 @@ export async function findMaxWithdrawalAmount(
       maxPossibleAmount: maxPossible,
       isMaxAmount: false,
       isCapped: maxPossible === 0n,
-      impact: zeroWithdrawalImpact(markets, idleAssets, incMkts),
+      impact: zeroWithdrawalImpact(markets, incMkts),
     }
   }
 
   const current = weightedVaultApyDetailed(markets)
-  const totalVaultAssets = markets.reduce((acc, m) => acc + m.vaultSupplyAssets, 0n) + idleAssets
 
   // Helper: is this amount acceptable (APY impact + custom constraint)?
   async function isAcceptable(amount: bigint): Promise<boolean> {
     const { sim, withdrawable, remaining } = simulateWithdrawal(markets, amount, idleAssets)
-    const isFullDrain = withdrawable >= totalVaultAssets
-    const simulated = isFullDrain ? makeFullDrainSnapshot(current) : weightedVaultApyDetailed(markets, {}, sim)
+    const simulated = weightedVaultApyDetailed(markets, {}, sim)
     const impact = Math.abs(simulated.apy - current.apy)
     if (impact > maxImpact) return false
     if (!constraint) return true
@@ -305,8 +291,7 @@ export async function findMaxWithdrawalAmount(
   // Fast path: full effectiveMax within threshold
   if (await isAcceptable(effectiveMax)) {
     const { sim, withdrawable, remaining } = simulateWithdrawal(markets, effectiveMax, idleAssets)
-    const simulated =
-      withdrawable >= totalVaultAssets ? makeFullDrainSnapshot(current) : weightedVaultApyDetailed(markets, {}, sim)
+    const simulated = weightedVaultApyDetailed(markets, {}, sim)
     return {
       amount: effectiveMax,
       maxPossibleAmount: maxPossible,
@@ -323,7 +308,7 @@ export async function findMaxWithdrawalAmount(
       maxPossibleAmount: maxPossible,
       isMaxAmount: false,
       isCapped: false,
-      impact: zeroWithdrawalImpact(markets, idleAssets, incMkts),
+      impact: zeroWithdrawalImpact(markets, incMkts),
     }
   }
 
@@ -343,9 +328,15 @@ export async function findMaxWithdrawalAmount(
     }
   }
 
+  if (constraint && lo + step <= effectiveMax && (await isAcceptable(lo + step))) {
+    console.warn(
+      '[morpho-apy] findMaxWithdrawalAmount: constraint may not be monotonic — ' +
+        'amount above the binary search result still passes. Results may be inaccurate.',
+    )
+  }
+
   const { sim, withdrawable, remaining } = simulateWithdrawal(markets, lo, idleAssets)
-  const simulated =
-    withdrawable >= totalVaultAssets ? makeFullDrainSnapshot(current) : weightedVaultApyDetailed(markets, {}, sim)
+  const simulated = weightedVaultApyDetailed(markets, {}, sim)
   return {
     amount: lo,
     maxPossibleAmount: maxPossible,

src/math.ts

@@ -74,7 +74,7 @@ export function estimateMarketApy(
     return { supplyApy: 0, borrowApy: 0 }
   }
 
-  let util = Math.min(totalBorrows / supply, 0.9999) // clamp to avoid division by zero
+  let util = Math.min(totalBorrows / supply, 1.0)
   if (util < 0.0001) util = 0
 
   const ratePerSec = rateAtTarget / WAD
@@ -117,13 +117,14 @@ export function weightedVaultApyDetailed(
   for (const m of markets) {
     const scale = Math.pow(10, m.decimals)
 
-    // Apply deposit simulation: increase totalSupplyAssets for target markets
-    let simSupply = depositSim[m.marketId] ? m.totalSupplyAssets + depositSim[m.marketId] : m.totalSupplyAssets
+    // Apply deposit simulation: increase both totalSupplyAssets and vaultSupplyAssets
+    const dSim = depositSim[m.marketId] ?? 0n
+    let simSupply = m.totalSupplyAssets + dSim
 
     // Apply withdrawal simulation: decrease both totalSupplyAssets and vaultSupplyAssets
     const wSim = withdrawalSim[m.marketId] ?? 0n
     simSupply = simSupply - wSim
-    const simVaultSupply = m.vaultSupplyAssets - wSim
+    const simVaultSupply = m.vaultSupplyAssets + dSim - wSim
     warnIfPrecisionRisk(m.marketId, m.decimals, simSupply, simVaultSupply)
 
     const supply = Number(simSupply) / scale
@@ -153,10 +154,7 @@ export function weightedVaultApyDetailed(
   }
 
   if (totalWeight <= 0) {
-    throw new Error(
-      `[morpho-apy] Vault has zero supply position across all ${markets.length} market(s). ` +
-        `Check vault address or wait for funds to be deployed.`,
-    )
+    return { apy: 0, markets: details }
   }
 
   // Fill in allocationPct
@@ -285,15 +283,13 @@ export function mergeMarketDetails(current: MarketApyDetail[], simulated: Market
         allocationPct: c.allocationPct,
         vaultSupplyAssets: c.vaultSupplyAssets,
       },
-      simulated: s
-        ? {
-            supplyApy: s.supplyApy,
-            borrowApy: s.borrowApy,
-            utilization: s.utilization,
-            allocationPct: s.allocationPct,
-            vaultSupplyAssets: s.vaultSupplyAssets,
-          }
-        : { supplyApy: 0, borrowApy: 0, utilization: 0, allocationPct: 0, vaultSupplyAssets: 0n },
+      simulated: {
+        supplyApy: s.supplyApy,
+        borrowApy: s.borrowApy,
+        utilization: s.utilization,
+        allocationPct: s.allocationPct,
+        vaultSupplyAssets: s.vaultSupplyAssets,
+      },
     }
   })
 }

src/withdrawal-impact.ts

@@ -5,18 +5,6 @@ import { fetchVaultApyViem } from './fetch.js'
 import { mergeMarketDetails, simulateWithdrawal, weightedVaultApyDetailed } from './math.js'
 import type { WithdrawalImpactResult } from './types.js'
 
-function makeFullDrainMarketDetails(current: ReturnType<typeof weightedVaultApyDetailed>) {
-  return current.markets.map((m) => ({
-    marketId: m.marketId,
-    name: m.name,
-    supplyApy: 0,
-    borrowApy: 0,
-    utilization: 0,
-    allocationPct: 0,
-    vaultSupplyAssets: 0n,
-  }))
-}
-
 /**
  * Compute the APY impact of a withdrawal from a MetaMorpho vault.
  * Makes live on-chain RPC calls via the provided viem PublicClient.
@@ -54,12 +42,7 @@ export async function computeWithdrawalImpact(
   const current = weightedVaultApyDetailed(markets)
   const { sim, withdrawable, remaining } = simulateWithdrawal(markets, withdrawAmount, idleAssets)
 
-  // Edge case: full withdrawal drains all vault positions
-  const totalVaultAssets = markets.reduce((acc, m) => acc + m.vaultSupplyAssets, 0n) + idleAssets
-  const simulated =
-    withdrawable >= totalVaultAssets
-      ? { apy: 0, markets: makeFullDrainMarketDetails(current) }
-      : weightedVaultApyDetailed(markets, {}, sim)
+  const simulated = weightedVaultApyDetailed(markets, {}, sim)
   const impact = simulated.apy - current.apy
 
   return {

test/math.test.ts

@@ -123,9 +123,9 @@ describe('weightedVaultApy', () => {
     expect(combined).toBeLessThan(apyA)
   })
 
-  it('throws when all markets have zero vault supply', () => {
+  it('returns zero APY when all markets have zero vault supply', () => {
     const market = makeMarket({ vaultSupplyAssets: 0n })
-    expect(() => weightedVaultApy([market])).toThrow(/zero supply position/)
+    expect(weightedVaultApy([market])).toBe(0)
   })
 
   it('skips markets with zero vault supply', () => {