Dex_Finance_Vault (DefiLlama#11037)

* wip dex_finance_vaults

* WIP dex-finance

* restore

* batch fetch farm data

* bugfix

* feat:DexFinance-vault Adapter

* revert using last logic sequential call

* exclude gDEX

* use addERC721Data instead of custom function

* rm call tokenId from getVaultDatas since its call in addERC721Data

---------

Co-authored-by: 0xpeluche <[email protected]>
Co-authored-by: g1nt0ki <[email protected]>

Author: 3 people

projects/agentfi/index.js

@@ -19,10 +19,8 @@ async function tvl(api) {
     const blasterswapv2 = dexBalancerAgents.map(i => [uniV2Lp.blasterswap, i.agentAddress])
     const ringv2 = dexBalancerAgents.map(i => [uniV2Lp.ring, i.agentAddress])
 
-    const blasterswapV3 = concentratedLiquidityAgents.map(i => [uniV3NftManager.blasterswap, i.agentAddress])
-    const blasterswap2V3 = concentratedLiquidityAgents.map(i => [uniV3NftManager.blasterswap2, i.agentAddress])
-    const thrusterV3 = concentratedLiquidityAgents.map(i => [uniV3NftManager.thruster, i.agentAddress])
-
+    const agents = concentratedLiquidityAgents.map(i => i.agentAddress)
+    await sumTokens2({ api, owners: agents, uniV3ExtraConfig: { nftAddress: [uniV3NftManager.blasterswap, uniV3NftManager.blasterswap2, uniV3NftManager.thruster]}})
 
     await getTvlForDexBalancer(dexBalancerAgents.map(i => i.agentAddress), api)
     await getTvlForLooperWithOrbit(looperAgentsAddresses, api)
@@ -33,11 +31,6 @@ async function tvl(api) {
             ...blasterswapv2,
             ...ringv2,
         ],
-        uniV3nftsAndOwners: [
-            ...blasterswapV3,
-            ...blasterswap2V3,
-            ...thrusterV3
-        ],
         resolveLP: true,
         api,
     })

projects/dexfinance-vault/abi.js

@@ -0,0 +1,25 @@
+exports.abi = {
+  factory: {
+    vaultsLength: "function vaultsCount() view returns (uint256)",
+    vaults: "function vaults(uint256 index) view returns (address)",
+    farmCalculationConnector:
+      "function farmCalculationConnector(address) view returns (address)",
+  },
+  vault: {
+    liquidity: "function liquidity(address) view returns (uint256 liquidity_)",
+    farmsLength: "uint256:farmsCount",
+    farmConnector: "function farmConnector(address) view returns (address)",
+    farms:
+      "function farms(uint256 index) view returns (tuple(address beacon, uint256 percent, bytes data))",
+  },
+  farm: {
+    stakingToken: "function stakingToken() view returns (address)",
+    farm: "address:farm",
+    type: "string:stakingTokenType",
+    tokenId: "uint256:tokenId",
+    stakingTokenLiquidity:
+      "function stakingTokenLiquidity(uint256 tokenId_) view returns (uint256 liquidity_)",
+    stakingTokenData:
+      "function stakingTokenData() view returns ((string stakingTokenType, address token0, address token1, uint24 fee, int24 tickLower, int24 tickUpper, (uint256 sqrtPriceX96LowInit, uint256 sqrtPriceX96UpInit, uint256 sqrtPriceX96LowLimit, uint256 sqrtPriceX96UpLimit, uint256 sqrtPriceX96ApproxPricePercent, uint256 sqrtPriceX96ShiftPercentLow, uint256 sqrtPriceX96ShiftPercentUp, uint256 sqrtPriceX96DefaultShiftPercentLow, uint256 sqrtPriceX96DefaultShiftPercentUp) pricesData, (address tokenIn, address tokenOut)[] swapsToken0ToNative, (address tokenIn, address tokenOut)[] swapsToken1ToNative, (address tokenIn, address tokenOut)[] swapsNativeToToken0, (address tokenIn, address tokenOut)[] swapsNativeToToken1))",
+  }
+};

projects/dexfinance-vault/index.js

@@ -0,0 +1,132 @@
+const { sumTokens2, addUniV3LikePosition } = require("../helper/unwrapLPs");
+const { abi } = require("./abi");
+
+const CONFIG = {
+  optimism: {
+    factory: "0xd4f1a99212e5be72426bde45abadef66d7d6edf3",
+  },
+  fantom: {
+    factory: "0x9b7e30644a9b37eebaa7158129b03f5a3088659d",
+  },
+  pulse: {
+    factory: "0xac297968C97EF5686c79640960D106f65C307a37",
+    USDEX_PLUS: "0xaA2C47a35C1298795B5271490971Ec4874C8e53d",
+  },
+  base: {
+    factory: "0x714c94b9820d7d73e61510e4c18b91f995a895c1",
+  },
+  arbitrum: {
+    factory: "0xe31fceaf93667365ce1e9edad3bed4a7dd0fc01a",
+    USDEX_PLUS: "0x4117EC0A779448872d3820f37bA2060Ae0B7C34B",
+    gDEX: "0x92a212d9f5eef0b262ac7d84aea64a0d0758b94f"
+  },
+  avax: {
+    factory: "0x6b714e6296b8b977e1d5ecb595197649e10a3db1",
+  },
+  bsc: {
+    factory: "0x3ace08b10b5c08a17d1c46277d65c81249e65f44",
+  },
+  // manta: {
+  //   factory: "0x714C94B9820D7D73e61510e4C18B91F995A895C1",
+  // },
+};
+
+const getVaults = async (api, factory) => {
+  const vaults = await api.fetchList({ lengthAbi: abi.factory.vaultsLength, itemAbi: abi.factory.vaults, target: factory, });
+  const farmsAll = await api.fetchList({ lengthAbi: abi.vault.farmsLength, itemAbi: abi.vault.farms, targets: vaults, groupedByInput: true })
+  const items = []
+  vaults.map((vault, i) => items.push(farmsAll[i].map((farm) => ({ vault, farm }))))
+  return items.flat()
+};
+
+const getVaultsConnectors = async (api, factory, vaultFarms) => {
+  const connectorsCalls = vaultFarms.map(({ farm, vault }) => ({ params: farm.beacon, target: vault, }));
+  const calculationConnectorCalls = vaultFarms.map(({ farm }) => farm.beacon);
+  const connectors = await api.multiCall({ abi: abi.vault.farmConnector, calls: connectorsCalls })
+  const calculationConnectors = await api.multiCall({ abi: abi.factory.farmCalculationConnector, calls: calculationConnectorCalls, target: factory })
+
+  vaultFarms.forEach((item, i) => {
+    delete item.farm.data
+    item.connector = connectors[i]
+    item.calculationConnector = calculationConnectors[i]
+  })
+}
+
+const getVaultsDatas = async (api, vaultFarms) => {
+  const calls = vaultFarms.map(({ connector }) => connector)
+  const liquidityCalls = vaultFarms.map(({ calculationConnector, connector }) => ({ target: calculationConnector, params: [connector] }))
+
+  const [types, stakingTokens, liquidities] =
+    await Promise.all([
+      api.multiCall({ calls, abi: abi.farm.type }),
+      api.multiCall({ calls, abi: abi.farm.stakingToken }),
+      api.multiCall({ calls: liquidityCalls, abi: abi.vault.liquidity }),
+    ]);
+
+  vaultFarms.forEach((item, i) => {
+    item.type = types[i]
+    item.stakingToken = stakingTokens[i]
+    item.liquidity = liquidities[i]
+  })
+};
+
+const groupBy = (array, keyFn) => {
+  return array.reduce((acc, item) => {
+    const key = keyFn(item);
+    if (!acc[key]) {
+      acc[key] = [];
+    }
+    acc[key].push(item);
+    return acc;
+  }, {});
+};
+
+const lpv2Balances = async (api, farms) => {
+  farms.forEach(({ stakingToken, liquidity }) => {
+    api.add(stakingToken, liquidity);
+  });
+};
+
+async function addERC721Data(api, vaultFarms) {
+  const positionIds = await api.multiCall({ abi: abi.farm.tokenId, calls: vaultFarms.map(i => i.connector) })
+  const nftPositionMapping = {}
+  vaultFarms.forEach((item, i) => {
+    if (!+positionIds[i])
+      return;
+
+    const nft = item.stakingToken.toLowerCase()
+    if (!nftPositionMapping[nft]) nftPositionMapping[nft] = []
+    nftPositionMapping[nft].push(positionIds[i])
+  })
+  for (const [nftAddress, positionIds] of Object.entries(nftPositionMapping))
+    await sumTokens2({ api, uniV3ExtraConfig: { nftAddress, positionIds, } })
+}
+
+const tvl = async (api) => {
+  const { factory, USDEX_PLUS, gDEX } = CONFIG[api.chain];
+  const vaultFarms = await getVaults(api, factory);
+  await getVaultsConnectors(api, factory, vaultFarms);
+  await getVaultsDatas(api, vaultFarms);
+  const sortedFarms = groupBy(vaultFarms, ({ type }) => `${type}`);
+
+  const lpv2Farms = Object.keys(sortedFarms)
+    .filter((key) => !key.includes("ERC721"))
+    .flatMap((key) => sortedFarms[key]);
+
+  const lpv3Farms = Object.keys(sortedFarms)
+    .filter((key) => key.includes("ERC721"))
+    .flatMap((key) => sortedFarms[key]);
+
+  await Promise.all([
+    lpv2Balances(api, lpv2Farms),
+    addERC721Data(api, lpv3Farms)
+  ])
+
+  if (USDEX_PLUS) api.removeTokenBalance(USDEX_PLUS);
+  if (gDEX) api.removeTokenBalance(gDEX);
+  return sumTokens2({ api, resolveLP: true });
+};
+
+Object.keys(CONFIG).forEach((chain) => {
+  module.exports[chain] = { tvl, };
+})

projects/helper/tokenMapping.js

@@ -60,6 +60,9 @@ const fixBalancesTokens = {
   bfc: {
     '0x6906Ccda405926FC3f04240187dd4fAd5DF6d555': { coingeckoId: "bitcoin-usd-btcfi", decimals: 18, },
   },
+  pulse: {
+    '0x30fcb23a906493371b1721c8feb8815804808d74': { coingeckoId: 'savings-dai', decimals: 18 },
+  }
 }
 
 ibcChains.forEach(chain => fixBalancesTokens[chain] = { ...ibcMappings, ...(fixBalancesTokens[chain] || {}) })

projects/helper/unwrapLPs.js

@@ -193,6 +193,8 @@ async function sumLPWithOnlyOneTokenOtherThanKnown(balances, lpToken, owner, tok
 
 const PANCAKE_NFT_ADDRESS = '0x46A15B0b27311cedF172AB29E4f4766fbE7F4364'
 async function unwrapUniswapV3NFTs({ balances = {}, nftsAndOwners = [], block, chain = 'ethereum', owner, nftAddress, owners, blacklistedTokens = [], whitelistedTokens = [], uniV3ExtraConfig = {} }) {
+  nftAddress = nftAddress ?? uniV3ExtraConfig.nftAddress
+  const commonConfig = { balances, owner, owners, chain, block, blacklistedTokens, whitelistedTokens, uniV3ExtraConfig, }
   // https://docs.uniswap.org/contracts/v3/reference/deployments
   if (!nftsAndOwners.length) {
     if (!nftAddress)
@@ -209,39 +211,51 @@ async function unwrapUniswapV3NFTs({ balances = {}, nftsAndOwners = [], block, c
         default: throw new Error('missing default uniswap nft address chain: ' + chain)
       }
 
-    if ((!owners || !owners.length) && owner)
-      owners = [owner]
-    owners = getUniqueAddresses(owners, chain)
-    if (Array.isArray(nftAddress))
-      nftsAndOwners = nftAddress.map(nft => owners.map(o => [nft, o])).flat()
-    else
-      nftsAndOwners = owners.map(o => [nftAddress, o])
-  }
-  await Promise.all(nftsAndOwners.map(([nftAddress, owner]) => unwrapUniswapV3NFT({ balances, owner, nftAddress, block, chain, blacklistedTokens, whitelistedTokens, uniV3ExtraConfig, })))
+    if (Array.isArray(nftAddress)) {
+      await Promise.all(nftAddress.map((addr) => unwrapUniswapV3NFT({ ...commonConfig, nftAddress: addr, })))
+    } else
+      await unwrapUniswapV3NFT({ ...commonConfig, nftAddress, })
+
+  } else
+    await Promise.all(nftsAndOwners.map(([nftAddress, owner]) => unwrapUniswapV3NFT({ ...commonConfig, owner, nftAddress, })))
   return balances
 }
 
 const factories = {}
 
 const getFactoryKey = (chain, nftAddress) => `${chain}:${nftAddress}`.toLowerCase()
 
-async function unwrapUniswapV3NFT({ balances, owner, nftAddress, block, chain = 'ethereum', blacklistedTokens = [], whitelistedTokens = [], uniV3ExtraConfig = {}, }) {
+async function unwrapUniswapV3NFT({ balances, owner, owners, nftAddress, block, chain = 'ethereum', blacklistedTokens = [], whitelistedTokens = [], uniV3ExtraConfig = {}, }) {
 
   blacklistedTokens = getUniqueAddresses(blacklistedTokens, chain)
   whitelistedTokens = getUniqueAddresses(whitelistedTokens, chain)
   let nftIdFetcher = uniV3ExtraConfig.nftIdFetcher ?? nftAddress
 
-  const nftPositions = (await sdk.api.erc20.balanceOf({ target: nftIdFetcher, owner, block, chain })).output
   const factoryKey = getFactoryKey(chain, nftAddress)
   if (!factories[factoryKey]) factories[factoryKey] = sdk.api.abi.call({ target: nftAddress, abi: wildCreditABI.factory, block, chain })
   let factory = (await factories[factoryKey]).output
   if (factory.toLowerCase() === '0xa08ae3d3f4da51c22d3c041e468bdf4c61405aab') // thruster finance has a bug where they set the pool deployer instead of the factory
     factory = '0x71b08f13B3c3aF35aAdEb3949AFEb1ded1016127'
 
-  const positionIds = (await sdk.api.abi.multiCall({
-    block, chain, abi: wildCreditABI.tokenOfOwnerByIndex, target: nftIdFetcher,
-    calls: Array(Number(nftPositions)).fill(0).map((_, index) => ({ params: [owner, index] })),
-  })).output.map(positionIdCall => positionIdCall.output)
+  let positionIds = uniV3ExtraConfig.positionIds
+  if (!positionIds) {
+    if (!owners && owner) owners = [owner]
+    owners = getUniqueAddresses(owners, chain)
+    const { output: lengths } = await sdk.api.abi.multiCall({
+      block, chain, abi: wildCreditABI.balanceOf,
+      calls: owners.map((params) => ({ target: nftIdFetcher, params, })),
+    })
+    const positionIDCalls = []
+    for (let i = 0; i < owners.length; i++) {
+      const length = lengths[i].output
+      positionIDCalls.push(...createIncrementArray(length).map(j => ({ params: [owners[i], j] })))
+    }
+
+    positionIds = (await sdk.api.abi.multiCall({
+      block, chain, abi: wildCreditABI.tokenOfOwnerByIndex, target: nftIdFetcher,
+      calls: positionIDCalls,
+    })).output.map(positionIdCall => positionIdCall.output)
+  }
 
   const positions = (await sdk.api.abi.multiCall({
     block, chain, abi: wildCreditABI.positions, target: nftAddress,
@@ -846,7 +860,11 @@ async function sumTokens2({
   fetchCoValentTokens = false,
   tokenConfig = {},
   sumChunkSize = undefined,
-  uniV3ExtraConfig = {},
+  uniV3ExtraConfig = {
+    // positionIds
+    // nftAddress
+    // nftIdFetcher
+  },
   resolveICHIVault = false,
   solidlyVeNfts = [],
 }) {

projects/thetanuts/index.js

@@ -1,5 +1,5 @@
 const ADDRESSES = require('../helper/coreAssets.json')
-const { sumTokensExport } = require('../helper/unwrapLPs')
+const { sumTokensExport, sumTokens2 } = require('../helper/unwrapLPs')
 
 // Ethereum Vaults
 const ethCallVault = '0x9014f8E90423766343Ed4fe41668563526dF6715'
@@ -240,11 +240,11 @@ const config = {
       [PTrsETH_26SEP24, aPTrsETH_26SEP24,],
       [PTweETH_26SEP24, aPTweETH_26SEP24,],
     ],
-    LLVOwners: [
-      [univ3nft_arb, arbC_LLV,],
-      [univ3nft_arb, arbP_LLV,],
-      [univ3nft_arb, ethC_LLV,],
-      [univ3nft_arb, ethP_LLV,],
+    uniV3Owners: [
+       arbC_LLV,
+       arbP_LLV,
+       ethC_LLV,
+       ethP_LLV,
     ]
   },
   fantom: {
@@ -310,8 +310,11 @@ const config = {
 }
 
 Object.keys(config).forEach(chain => {
-  const { tokensAndOwners, LLVOwners } = config[chain]
+  const { tokensAndOwners, uniV3Owners } = config[chain]
   module.exports[chain] = {
-    tvl: sumTokensExport({ tokensAndOwners, resolveUniV3 : LLVOwners != null && LLVOwners.length > 0 ? true : false,  uniV3nftsAndOwners : LLVOwners })
+    tvl: async (api) => {
+      if (uniV3Owners) await sumTokens2({ api, owners: uniV3Owners, resolveUniV3: true})
+      return sumTokens2({ api, tokensAndOwners})
+    }
   }
 })