fix type issues

Author: apexearth

src/server-extension/morpho.ts

@@ -164,8 +164,17 @@ export class MorphoVaultApyResolver {
     @Arg('depositAmount', () => String) depositAmount: string,
     @Info() _info: GraphQLResolveInfo,
   ): Promise<MorphoDepositImpactResult> {
+    let amount: bigint
+    try {
+      amount = BigInt(depositAmount)
+    } catch {
+      throw new Error(`Invalid depositAmount: "${depositAmount}". Must be a valid integer string.`)
+    }
+    if (amount <= 0n) {
+      throw new Error(`depositAmount must be positive, got ${depositAmount}`)
+    }
     const client = getViemClient(chainId)
-    const result = await computeDepositImpact(client as any, chainId, vaultAddress, depositAmount)
+    const result = await computeDepositImpact(client as any, chainId, vaultAddress, amount)
     return new MorphoDepositImpactResult(result)
   }
 }

src/templates/morpho/deposit-impact.ts

@@ -17,13 +17,13 @@ export interface DepositImpactResult {
  * @param client   viem PublicClient for the target chain
  * @param chainId  Chain ID (used to resolve the Morpho Blue singleton address)
  * @param vaultAddress  MetaMorpho V1.1 vault address
- * @param depositAmount  Deposit size as a decimal string in loan-token units
+ * @param depositAmount  Deposit size in loan-token base units (e.g. 1e18 for 1 ETH)
  */
 export async function computeDepositImpact(
   client: PublicClient,
   chainId: number,
   vaultAddress: string,
-  depositAmount: string,
+  depositAmount: bigint,
 ): Promise<DepositImpactResult> {
   const morphoAddress = ousd.morpho.blue[chainId]
   if (!morphoAddress) {
@@ -36,14 +36,8 @@ export async function computeDepositImpact(
   }
 
   const { apy: currentApy, markets } = result
-  const sim = simulateDeposit(markets, BigInt(depositAmount))
-
-  let newApy = currentApy
-  try {
-    newApy = weightedVaultApy(markets, sim)
-  } catch {
-    // If simulation fails, newApy stays at currentApy → impactBps = 0
-  }
+  const sim = simulateDeposit(markets, depositAmount)
+  const newApy = weightedVaultApy(markets, sim)
 
   return {
     currentApy,

src/templates/morpho/fetch.ts

@@ -9,6 +9,7 @@
  * - `fetchVaultApy` — Subsquid version, returns null if vault has no markets
  * - `fetchVaultApyViem` — viem version, returns { apy, markets } or null
  */
+import { compact } from 'lodash'
 import type { PublicClient } from 'viem'
 import { getAddress } from 'viem'
 
@@ -192,8 +193,18 @@ export async function fetchVaultMarketsViem(
 
   // 2. Market IDs from both queues
   const queueCalls = [
-    ...Array.from({ length: supplyLenN }, (_, i) => ({ address: vault, abi: META_MORPHO_ABI_JSON, functionName: 'supplyQueue' as const, args: [BigInt(i)] })),
-    ...Array.from({ length: withdrawLenN }, (_, i) => ({ address: vault, abi: META_MORPHO_ABI_JSON, functionName: 'withdrawQueue' as const, args: [BigInt(i)] })),
+    ...Array.from({ length: supplyLenN }, (_, i) => ({
+      address: vault,
+      abi: META_MORPHO_ABI_JSON,
+      functionName: 'supplyQueue' as const,
+      args: [BigInt(i)],
+    })),
+    ...Array.from({ length: withdrawLenN }, (_, i) => ({
+      address: vault,
+      abi: META_MORPHO_ABI_JSON,
+      functionName: 'withdrawQueue' as const,
+      args: [BigInt(i)],
+    })),
   ]
 
   const queueResults = await client.multicall({ contracts: queueCalls, allowFailure: false })
@@ -206,53 +217,47 @@ export async function fetchVaultMarketsViem(
 
   if (allIds.length === 0) return []
 
-  // 4. Fetch market state, position, params, config
-  const perMarketCalls = allIds.flatMap((id) => [
-    { address: morpho, abi: MORPHO_ABI_JSON, functionName: 'market' as const, args: [id] },
-    { address: morpho, abi: MORPHO_ABI_JSON, functionName: 'position' as const, args: [id, vault] },
-    { address: morpho, abi: MORPHO_ABI_JSON, functionName: 'idToMarketParams' as const, args: [id] },
-    { address: vault, abi: META_MORPHO_ABI_JSON, functionName: 'config' as const, args: [id] },
+  // 4. Fetch market state, position, params, config (parallel multicalls)
+  const [marketStates, positions, marketParams, configs] = await Promise.all([
+    client.multicall({
+      contracts: allIds.map((id) => ({ address: morpho, abi: MORPHO_ABI_JSON, functionName: 'market' as const, args: [id] })),
+      allowFailure: false,
+    }),
+    client.multicall({
+      contracts: allIds.map((id) => ({ address: morpho, abi: MORPHO_ABI_JSON, functionName: 'position' as const, args: [id, vault] })),
+      allowFailure: false,
+    }),
+    client.multicall({
+      contracts: allIds.map((id) => ({ address: morpho, abi: MORPHO_ABI_JSON, functionName: 'idToMarketParams' as const, args: [id] })),
+      allowFailure: false,
+    }),
+    client.multicall({
+      contracts: allIds.map((id) => ({ address: vault, abi: META_MORPHO_ABI_JSON, functionName: 'config' as const, args: [id] })),
+      allowFailure: false,
+    }),
   ])
 
-  const perMarketResults = await client.multicall({ contracts: perMarketCalls, allowFailure: false })
-
-  // Parse per-market results (4 calls per market)
-  // viem returns multi-output functions as arrays, so destructure by position.
-  const parsed = allIds.map((_, i) => {
-    const base = i * 4
-    const [totalSupplyAssets, totalSupplyShares, totalBorrowAssets, , , fee] = perMarketResults[base] as unknown as bigint[]
-    const [supplyShares] = perMarketResults[base + 1] as unknown as bigint[]
-    const [loanToken, , , irm] = perMarketResults[base + 2] as unknown as `0x${string}`[]
-    const [cap] = perMarketResults[base + 3] as unknown as bigint[]
-    return {
-      state: { totalSupplyAssets, totalSupplyShares, totalBorrowAssets, fee },
-      pos: { supplyShares },
-      params: { loanToken, irm },
-      cfg: { cap },
-    }
-  })
-
   // 5. Per-market IRM + decimals (single multicall batch)
-  const irmAndDecimalCalls = parsed.flatMap(({ params }, i) => {
-    const hasIrm = params.irm && params.irm.toLowerCase() !== ADDRESS_ZERO
+  const irmAndDecimalCalls = marketParams.flatMap(([loanToken, , , irm], i) => {
+    const hasIrm = irm && irm.toLowerCase() !== ADDRESS_ZERO
     return [
       hasIrm
-        ? { address: getAddress(params.irm), abi: IRM_ABI_JSON, functionName: 'rateAtTarget' as const, args: [allIds[i]] }
+        ? { address: getAddress(irm), abi: IRM_ABI_JSON, functionName: 'rateAtTarget' as const, args: [allIds[i]] }
         : null,
-      { address: getAddress(params.loanToken), abi: ERC20_ABI_JSON, functionName: 'decimals' as const },
+      { address: getAddress(loanToken), abi: ERC20_ABI_JSON, functionName: 'decimals' as const },
     ]
   })
   const irmAndDecimalResults = await client.multicall({
-    contracts: irmAndDecimalCalls.filter((c): c is NonNullable<typeof c> => c !== null),
+    contracts: compact(irmAndDecimalCalls),
     allowFailure: true,
   })
 
   // Map results back, accounting for skipped IRM calls
   let resultIdx = 0
   const ratesAtTarget: bigint[] = []
   const decimals: number[] = []
-  for (const { params } of parsed) {
-    const hasIrm = params.irm && params.irm.toLowerCase() !== ADDRESS_ZERO
+  for (const [, , , irm] of marketParams) {
+    const hasIrm = irm && irm.toLowerCase() !== ADDRESS_ZERO
     if (hasIrm) {
       const r = irmAndDecimalResults[resultIdx++]
       const rate = r.status === 'success' ? (r.result as bigint) : 0n
@@ -266,20 +271,26 @@ export async function fetchVaultMarketsViem(
 
   // 6. Assemble
   return allIds.map((marketId, i) => {
-    const { state, pos, cfg } = parsed[i]
+    // market: [totalSupplyAssets, totalSupplyShares, totalBorrowAssets, totalBorrowShares, lastUpdate, fee]
+    const [totalSupplyAssets, totalSupplyShares, totalBorrowAssets, , , fee] = marketStates[i]
+    // position: [supplyShares, borrowShares, collateral]
+    const [supplyShares] = positions[i]
+    // config: [cap, enabled, removableAt]
+    const [cap] = configs[i]
+
     let vaultSupplyAssets = 0n
-    if (pos.supplyShares > 0n && state.totalSupplyShares > 0n) {
-      vaultSupplyAssets = (pos.supplyShares * state.totalSupplyAssets) / state.totalSupplyShares
+    if (supplyShares > 0n && totalSupplyShares > 0n) {
+      vaultSupplyAssets = (supplyShares * totalSupplyAssets) / totalSupplyShares
     }
 
     return {
       marketId,
-      totalSupplyAssets: state.totalSupplyAssets,
-      totalBorrowAssets: state.totalBorrowAssets,
-      fee: state.fee,
+      totalSupplyAssets,
+      totalBorrowAssets,
+      fee,
       vaultSupplyAssets,
       rateAtTarget: ratesAtTarget[i],
-      cap: cfg.cap,
+      cap,
       decimals: decimals[i],
       inSupplyQueue: supplySet.has(marketId as `0x${string}`),
     } satisfies MarketForApy

src/templates/morpho/math.ts

@@ -100,14 +100,13 @@ export function weightedVaultApy(markets: MarketForApy[], depositSim: Record<str
     // Apply deposit simulation: increase totalSupplyAssets for target markets
     const simSupply = depositSim[m.marketId] ? m.totalSupplyAssets + depositSim[m.marketId] : m.totalSupplyAssets
 
-    // Convert BigInt → float via string to avoid Number.MAX_SAFE_INTEGER overflow
-    const supply = Number(simSupply.toString()) / scale
-    const borrows = Number(m.totalBorrowAssets.toString()) / scale
-    const fee = Number(m.fee.toString()) // stays WAD-scaled; /WAD done inside estimateMarketApy
-    const rate = Number(m.rateAtTarget.toString()) // stays WAD-scaled
+    const supply = Number(simSupply) / scale
+    const borrows = Number(m.totalBorrowAssets) / scale
+    const fee = Number(m.fee) // stays WAD-scaled; /WAD done inside estimateMarketApy
+    const rate = Number(m.rateAtTarget) // stays WAD-scaled
 
     const { supplyApy } = estimateMarketApy(0, supply, borrows, fee, rate)
-    const weight = Number(m.vaultSupplyAssets.toString()) / scale
+    const weight = Number(m.vaultSupplyAssets) / scale
 
     if (weight <= 0) continue