fix spectra doublecount (#18537)

Author: RohanNero

projects/spectra-metavaults/index.js

@@ -1,9 +1,21 @@
 const ADDRESSES = require('../helper/coreAssets.json')
 const sdk = require("@defillama/sdk");
-const { getCache, setCache } = require("../helper/cache");
+const { getCache, setCache, getConfig } = require("../helper/cache");
 const ethers = require("ethers");
 const config = require("./config.json");
 
+// Chain name (as used in config.json) to Spectra API network slug
+const CHAIN_TO_API_NETWORK = {
+  ethereum: "ethereum",
+  arbitrum: "arbitrum",
+  base: "base",
+  avax: "avalanche",
+  katana: "katana",
+  flare: "flare",
+};
+
+const SPECTRA_API_BASE = "https://api.spectra.finance/v1";
+
 const LOG_CACHE_FOLDER = "logs";
 
 /**
@@ -104,6 +116,103 @@ const isMetavaultCountValid = (count) => {
   }
 };
 
+async function fetchMetavaultOwnerMap(chain) {
+  const ownerMap = {};
+  const network = CHAIN_TO_API_NETWORK[chain];
+  if (!network) return ownerMap;
+
+  try {
+    const metavaults = await getConfig(
+      `spectra-metavaults-api/${network}`,
+      `${SPECTRA_API_BASE}/${network}/metavaults`
+    );
+    if (!Array.isArray(metavaults)) return ownerMap;
+    for (const mv of metavaults) {
+      if (mv.address) {
+        ownerMap[mv.address.toLowerCase()] = mv;
+      }
+      if (mv.remote) {
+        for (const remoteChainId of Object.keys(mv.remote)) {
+          const remote = mv.remote[remoteChainId];
+          if (remote?.address) {
+            ownerMap[remote.address.toLowerCase()] = mv;
+          }
+        }
+      }
+    }
+  } catch (e) {
+    sdk.log(`spectra-metavaults: failed to fetch API for ${network}:`, e.message);
+  }
+
+  return ownerMap;
+}
+
+/**
+ * Compute the Spectra-allocated amount for a metavault across all chains,
+ * denominated in raw underlying token units (matching totalAssets units).
+ *
+ * "Spectra" = PT + YT + LP positions + wrapper IBT balances.
+ */
+function computeSpectraAllocation(metavault) {
+  if (!metavault?.positions?.length) return 0;
+
+  const underlyingDecimals = metavault.underlying?.decimals ?? metavault.decimals ?? 18;
+  let totalSpectraUnderlying = 0;
+
+  for (const pos of metavault.positions) {
+
+    const ptDecimals = pos.decimals ?? 18;
+    const pool = pos.pools?.[0];
+
+    // --- PT balance ---
+    const ptBalanceRaw = BigInt(pos.balance || 0);
+    if (ptBalanceRaw > 0n) {
+      let ptPriceUnderlying;
+      if (pool?.ptPrice?.underlying != null) {
+        ptPriceUnderlying = pool.ptPrice.underlying;
+      } else if (pos.maturityValue?.underlying != null) {
+        ptPriceUnderlying = pos.maturityValue.underlying;
+      }
+      if (ptPriceUnderlying != null) {
+        totalSpectraUnderlying +=
+          Number(ptBalanceRaw) / 10 ** ptDecimals * ptPriceUnderlying;
+      }
+    }
+
+    // --- YT balance ---
+    const ytBalanceRaw = BigInt(pos.yt?.balance || 0);
+    if (ytBalanceRaw > 0n && pool?.ytPrice?.underlying != null) {
+      totalSpectraUnderlying +=
+        Number(ytBalanceRaw) / 10 ** ptDecimals * pool.ytPrice.underlying;
+    }
+
+    // --- LP balances (across all pools) ---
+    if (pos.pools) {
+      for (const p of pos.pools) {
+        const lpBalanceRaw = BigInt(p.lpt?.balance || 0);
+        if (lpBalanceRaw > 0n && p.lpt?.price?.underlying != null) {
+          const lpDecimals = p.lpt.decimals ?? 18;
+          totalSpectraUnderlying +=
+            Number(lpBalanceRaw) / 10 ** lpDecimals * p.lpt.price.underlying;
+        }
+      }
+    }
+
+    // --- Wrapper IBT balance (IBT that wraps another token via Spectra) ---
+    if (pos.ibt?.baseIbt?.balance) {
+      const ibtBalanceRaw = BigInt(pos.ibt.baseIbt.balance);
+      if (ibtBalanceRaw > 0n && pos.ibt?.price?.underlying != null) {
+        const ibtDecimals = pos.ibt.decimals ?? 18;
+        totalSpectraUnderlying +=
+          Number(ibtBalanceRaw) / 10 ** ibtDecimals * pos.ibt.price.underlying;
+      }
+    }
+  }
+
+  // Convert from underlying floating-point back to raw token units
+  return Math.floor(totalSpectraUnderlying * 10 ** underlyingDecimals);
+}
+
 const getMetavaultTVL = async (api, metavaultSources) => {
   if (!metavaultSources.length) return;
 
@@ -119,6 +228,12 @@ const getMetavaultTVL = async (api, metavaultSources) => {
       throw e;
     }
   }
+  // Use a small buffer to avoid race conditions where the RPC node
+  // hasn't synced the very latest block yet (observed on katana)
+  toBlock = toBlock - 10;
+
+  // Fetch API metavault data (for Spectra allocation deduction)
+  const apiOwnerMap = await fetchMetavaultOwnerMap(api.chain);
 
   const logs = await getCachedEventLogs({
     chain: api.chain,
@@ -162,13 +277,18 @@ const getMetavaultTVL = async (api, metavaultSources) => {
     permitFailure: true,
   });
 
+  // Track infraVault to owner address for API lookup
   const uniqueInfraVaults = {};
-  validWrappers.forEach(({ infraVaultFromEvent }, i) => {
+  const infraVaultToOwner = {};
+  validWrappers.forEach(({ owner, wrapper, infraVaultFromEvent }, i) => {
     let infraVault = wrapperInfraVaults[i];
     if (!infraVault || infraVault.toLowerCase() === ZERO_ADDRESS)
       infraVault = infraVaultFromEvent;
     if (!infraVault || infraVault.toLowerCase() === ZERO_ADDRESS) return;
-    uniqueInfraVaults[infraVault.toLowerCase()] = infraVault;
+    const infraKey = infraVault.toLowerCase();
+    uniqueInfraVaults[infraKey] = infraVault;
+    // owner from the event is the metavault identity (matches API mv.address)
+    infraVaultToOwner[infraKey] = (typeof owner === 'string' ? owner : '').toLowerCase();
   });
 
   const infraVaults = Object.values(uniqueInfraVaults);
@@ -190,7 +310,20 @@ const getMetavaultTVL = async (api, metavaultSources) => {
   assets.forEach((asset, i) => {
     const balance = totalAssets[i];
     if (!asset || asset.toLowerCase() === ZERO_ADDRESS || !balance) return;
-    api.add(asset, balance);
+
+    // Deduct the portion already deposited into Spectra (PT/YT/LP/wrapper IBT)
+    // Skip entirely if we can't find this metavault in the API response
+    const infraKey = infraVaults[i].toLowerCase();
+    const ownerAddr = infraVaultToOwner[infraKey];
+    const apiMetavault = ownerAddr ? apiOwnerMap[ownerAddr] : undefined;
+    if (!apiMetavault) return;
+
+    const spectraAmount = BigInt(computeSpectraAllocation(apiMetavault));
+    const adjustedBalance = BigInt(balance) - spectraAmount;
+
+    if (adjustedBalance > 0n) {
+      api.add(asset, adjustedBalance.toString());
+    }
   });
 };
 
@@ -203,10 +336,10 @@ const tvl = async (api) => {
 };
 
 module.exports = {
-  methodology: `TVL is the total value of assets deposited in Spectra MetaVaults.`,
+  methodology: `TVL is the total value of assets deposited in Spectra MetaVaults, excluding the portion allocated to Spectra V2 (PT, YT, LP, wrapper IBT).`,
   hallmarks: [["2026-02-12", "MetaVaults Launch"]],
 };
 
 Object.keys(config).forEach((chain) => {
   module.exports[chain] = { tvl };
-});
+});