Merge branch 'DefiLlama:main' into main

Author: chandoling

pnpm-lock.yaml

@@ -1,14 +1,34 @@
+const { getLogs } = require("../helper/cache/getLogs");
 const { sumTokens2 } = require('../helper/unwrapLPs')
+const abi = require("../helper/abis/morpho.json");
 
 const contract = "0xde6e08ac208088cc62812ba30608d852c6b0ecbc"
+const fromBlock = 23214670
 
 async function tvl(api) {
   return sumTokens2({ tokens: ["0xd4fa2d31b7968e448877f69a96de69f5de8cd23e"], owner: contract, api })
 }
 
+const eventAbis = {
+  createMarket: 'event CreateMarket(bytes32 indexed id, (address loanToken, address collateralToken, address oracle, address irm, uint256 lltv, address creditLine) marketParams)'
+}
+
+async function borrowed(api) {
+  const logs = await getLogs({ api, target: contract, eventAbi: eventAbis.createMarket, fromBlock, onlyArgs: true })
+  const markets = logs.map((i) => i.id.toLowerCase())
+  const marketInfos = await api.multiCall({ target: contract, calls: markets, abi: abi.morphoBlueFunctions.idToMarketParams })
+  const marketDatas = await api.multiCall({ target: contract, calls: markets, abi: abi.morphoBlueFunctions.market })
+  
+  marketDatas.forEach((data, idx) => {
+    const { loanToken } = marketInfos[idx];
+    api.add(loanToken, data.totalBorrowAssets);
+  });
+}
+
 module.exports = {
   methodology: `We count the tokens on ${contract}`,
   ethereum: {
-    tvl
+    tvl,
+    borrowed,
   }
 }

projects/3jane-lending/index.js

@@ -59,5 +59,14 @@ module.exports = {
       await api.addTokens(tokens, tokenSupplies)
       return api.getBalances()
     }
+  },
+  bsc: {
+    tvl: async (api) => {
+      const tokenAPI = new sdk.ChainApi({ chain: 'polygon', timestamp: api.timestamp, });
+      const tokens = await getTokenList(tokenAPI, api.chainId)
+      const tokenSupplies = await api.multiCall({ abi: 'uint256:totalSupply', calls: tokens })
+      await api.addTokens(tokens, tokenSupplies)
+      return api.getBalances()
+    }
   }
 };

projects/DigiFT/index.js

@@ -1,7 +1,5 @@
-const sdk = require('@defillama/sdk');
 const abi = require("./abi.json");
 const { request, gql } = require("graphql-request");
-const { getBlock } = require('../helper/http')
 
 const VGHST_CONTRACT = "0x51195e21BDaE8722B29919db56d95Ef51FaecA6C";
 const GHST_CONTRACT = "0x385Eeac5cB85A38A9a07A70c73e0a3271CfB54A7";
@@ -27,61 +25,41 @@ query GET_SUMMONED_GOTCHIS ($minGotchiId: Int, $block: Int) {
     stakedAmount
   }
 }`
-async function getGotchisCollateral(timestamp, block) {
-  const allGotchis = [];
+async function getGotchisCollateral(block, api) {
   let minGotchiId = 0;
   while (minGotchiId !== -1) {
     const { aavegotchis } = await request(
       graphUrl,
-      graphQuery, 
-      {minGotchiId, block}
+      graphQuery,
+      { minGotchiId, block }
     );
     if (aavegotchis && aavegotchis.length > 0) {
       minGotchiId = parseInt(aavegotchis[aavegotchis.length - 1].gotchiId);
-      allGotchis.push(...aavegotchis);
+      aavegotchis.forEach(g => api.add(g.collateral, g.stakedAmount));
     } else {
       minGotchiId = -1;
     }
   }
-  const gotchisBalances = {
-    output: allGotchis.map(g => ({
-      input: {target: g.collateral},
-      success: true,
-      output: g.stakedAmount
-    }))
-  };
-
-  const balances = {};
-  sdk.util.sumMultiBalanceOf(balances, gotchisBalances, true, x => 'polygon:' + x);
-  return gotchisBalances;
 }
 
-async function tvl(timestamp, _, chainBlocks) {
-  const balances = {};
-  const block = await getBlock(timestamp, 'polygon', chainBlocks)
-  const transform = i => `polygon:${i}`;
+async function tvl(api) {
+  const block = await api.getBlock()
 
-  const collateralBalance = (await sdk.api.abi.call({
+  const collateralBalance = await api.call({
     abi: abi.totalGHST,
-    chain: 'polygon',
     target: VGHST_CONTRACT,
     params: [VGHST_CONTRACT],
-    block,
-  })).output;
-
-  sdk.util.sumSingleBalance(balances, transform(GHST_CONTRACT), collateralBalance)
-
-  const gotchisBalances = await getGotchisCollateral(timestamp, block-100);
-  sdk.util.sumMultiBalanceOf(balances, gotchisBalances, true, x => 'polygon:' + x);
+  })
+  api.add(GHST_CONTRACT, collateralBalance)
 
-
-  return balances;
+  // return getGotchisCollateral(block - 100, api);
 }
 
 module.exports = {
   methodology:
     "TVL counts the total GHST tokens that are staked by the Gotchi Vault vGHST contracts, as well as the collateral tokens that are locked in the Aavegotchis deposited in the Gotchi Vault contract",
-    polygon: {
+  polygon: {
     tvl,
-  }
+  },
+  deadFrom: '2025-10-10',
 };

projects/GotchiVault/index.js

@@ -1,25 +1,11 @@
-const sdk = require("@defillama/sdk");
+const { sumTokensExport } = require("../helper/unwrapLPs");
+const { nullAddress } = require("../helper/tokenMapping");
 
 // TroveManager holds total system collateral (deposited ETH)
-const TROVE_MANAGER_ADDRESS = "0x25d27cbdfaFb1B7314AC5e409a1F24112e376829";
-
-async function tvl(_, _b, {ethpow: block}) {
-  const troveEthTvl = (
-    await sdk.api.abi.call({
-      target: TROVE_MANAGER_ADDRESS,
-      chain: 'ethpow',
-      abi: "uint256:getEntireSystemColl",
-      block,
-    })
-  ).output;
-
-  return {
-    'coingecko:ethereum-pow-iou': troveEthTvl/1e18 ,
-  };
-}
+const TROVE_MANAGER_ADDRESS = "0x259ED2C59D350E608E1018162e641186c410c31B";
 
 module.exports = {
   ethpow: {
-    tvl,
+    tvl: sumTokensExport({ owners: [TROVE_MANAGER_ADDRESS], tokens: [nullAddress]}),
   }
 };

projects/RealProtocol/index.js

@@ -3,14 +3,16 @@ const { generateAtvExport } = require('../helper/atv-helper');
 
 // Configuration for all Aarna ATV vaults across chains
 const AARNA_CONFIG = {
-  methodology: 'TVL is calculated using direct on-chain storage contract queries via calculatePoolInUsd function for each âtv vault. This includes âtv802 (quant AI), âtv808 (asymmetric alpha), and âtv111 (multi layer yield) vaults deployed across Ethereum, Arbitrum, and Sonic chains.',
+  methodology: `TVL: Total value of all coins held in the smart contracts of the protocol
+  Fees: 1% deposit and 10% profit sharing (whereever applicable) fees from the vaults`,
 
   // Vault addresses by chain and type
   vaults: {
     ethereum: {
       'ATV-802': "0xb68e430c56ed9e548e864a68a60f9d41f993b32c",
       'ATV-808': "0x60697825812ecC1Fff07f41E2d3f5cf314674Fa6", 
-      'ATV-111': "0x72ec8447074dc0bfbedfb516cc250b525f3a4aba"
+      'ATV-111': "0x72ec8447074dc0bfbedfb516cc250b525f3a4aba",
+      'ATVPTMAX': "0xb9C1344105FaA4681bc7FFd68c5c526DA61F2AE8"
     },
     arbitrum: {
       'ATV-111': "0xe1a6bda42fbafae38607598386a1050613c1a64b"

projects/aarna/index.js

@@ -0,0 +1,8 @@
+const { aaveV3Export } = require("../helper/aave");
+
+const CONFIG = {
+  ethereum: ['0x53519c32f73fE1797d10210c4950fFeBa3b21504'],
+
+};
+
+module.exports = aaveV3Export(CONFIG)

projects/aave-horizon/index.js

@@ -2,7 +2,7 @@ const { aaveV3Export } = require("../helper/aave");
 
 // https://aave.com/docs/resources/addresses
 const CONFIG = {
-  ethereum: ['0x41393e5e337606dc3821075Af65AeE84D7688CBD', '0x08795CFE08C7a81dCDFf482BbAAF474B240f31cD', '0xE7d490885A68f00d9886508DF281D67263ed5758', '0x53519c32f73fE1797d10210c4950fFeBa3b21504'],
+  ethereum: ['0x41393e5e337606dc3821075Af65AeE84D7688CBD', '0x08795CFE08C7a81dCDFf482BbAAF474B240f31cD', '0xE7d490885A68f00d9886508DF281D67263ed5758'],
   polygon: ['0x7F23D86Ee20D869112572136221e173428DD740B'],
   avax: ['0x7F23D86Ee20D869112572136221e173428DD740B'],
   arbitrum: ['0x7F23D86Ee20D869112572136221e173428DD740B'],

projects/aave-v3/index.js

@@ -0,0 +1,81 @@
+const FACTORIES = [
+    '0x606556A6B544ecDcbf15aF73A63B67516dc16Ad7',
+    '0x8a5Caf00C3EB20aEC11Fc35C153a8601Cd127fEd',
+]
+
+const abis = {
+    strategyProxies: 'function strategyProxies(uint256) view returns (address)',
+    strategyVaults: 'function strategyVaults(address) view returns (address)',
+    convertToAssets: 'function convertToAssets(uint256) view returns (uint256)',
+    asset: 'function asset() view returns (address)',
+}
+
+const NULL_ADDRESS = '0x0000000000000000000000000000000000000000'
+
+async function getVaults(api) {
+    const vaults = new Set()
+    const batchSize = 20
+
+    for (const factory of FACTORIES) {
+        for (let start = 0; ; start += batchSize) {
+            const indexes = Array.from({ length: batchSize }, (_, i) => start + i)
+
+            const strategies = await api.multiCall({
+                target: factory,
+                abi: abis.strategyProxies,
+                calls: indexes.map((i) => ({ params: [i] })),
+                permitFailure: true,
+            })
+            const validStrategies = strategies.filter((s) => s && s !== NULL_ADDRESS)
+            if (!validStrategies.length) break
+
+            const factoryVaults = await api.multiCall({
+                target: factory,
+                abi: abis.strategyVaults,
+                calls: validStrategies.map((strategy) => ({ params: [strategy] })),
+                permitFailure: true,
+            })
+
+            factoryVaults.forEach((vault) => {
+                if (!vault || vault === NULL_ADDRESS) return
+                vaults.add(vault.toLowerCase())
+            })
+        }
+    }
+
+    return Array.from(vaults)
+}
+
+function tvl(isBorrowed) {
+    return async (api) => {
+        const vaults = await getVaults(api)
+        if (!vaults.length) return
+
+        const [supplies, underlyings] = await Promise.all([
+            api.multiCall({ abi: 'erc20:totalSupply', calls: vaults, permitFailure: true }),
+            api.multiCall({ abi: abis.asset, calls: vaults, permitFailure: true }),
+        ])
+        
+        const [totalAssets, liquidity] = await Promise.all([
+            api.multiCall({
+                abi: abis.convertToAssets,
+                calls: vaults.map((vault, i) => ({ target: vault, params: [supplies[i] || 0] })),
+                permitFailure: true,
+            }),
+            api.multiCall({ abi: 'erc20:balanceOf', calls: vaults.map((vault, i) => ({ target: underlyings[i], params: vault })), permitFailure: true })
+        ])
+
+        vaults.forEach((_, i) => {
+            if (!underlyings[i] || !totalAssets[i]) return
+            isBorrowed ? api.add(underlyings[i], totalAssets[i] - liquidity[i]) : api.add(underlyings[i], liquidity[i])
+        })
+    }
+}
+
+module.exports = {
+    methodology: 'TVL converts each vault totalSupply to underlying via convertToAssets(). Vaults are discovered from factory strategyProxies/strategyVaults.',
+    monad: {
+        tvl: tvl(false),
+        borrowed: tvl(true)
+    },
+}