feat: Adapter, double2win.xyz

projects/double2win/config.js

@@ -0,0 +1,29 @@
+module.exports = {
+  arbitrum: {
+    uniswapV2Vault: {
+      doubleContract: '0xBf212dEE0aea6531dEb0B02be6E70b527dDF8246',
+      fromBlock: 217487403,
+      type: 'v2-vault'
+    },
+    uniswapV2Migration: {
+      doubleContract: '0x1c6E7CE03ae7a9A252BcE0C9F871654dBB0C7ca5',
+      fromBlock: 217487754,
+      type: 'v2-lp'
+    },
+    uniswapV3Vault: {
+      doubleContract: '0x07116C5ED5cBb49464f64926Ba152B8985fe3AFf',
+      fromBlock: 217488144,
+      type: 'v3-vault'
+    },
+    uniswapV3Migration: {
+      doubleContract: '0x99F980fa0b1939A0A1033092EF2a668df8D8b70D',
+      fromBlock: 217488619,
+      type: 'v3-lp'
+    },
+    assetVault: {
+      doubleContract: '0x7C09A9c30736F17043Fe6D0C0A3D03a7Cf6e78FD',
+      fromBlock: 217484114,
+      type: 'asset-vault'
+    },
+  }
+};

projects/double2win/index.js

@@ -0,0 +1,119 @@
+const config = require("./config");
+const { sumTokens2 } = require('../helper/unwrapLPs')
+const { cachedGraphQuery } = require('../helper/cache');
+const { getTokenPrices } = require('../helper/unknownTokens');
+const { stripTokenHeader } = require('../helper/utils');
+const sdk = require('@defillama/sdk');
+const { getChainTransform, getFixBalances } = require("../helper/portedTokens");
+const { default: BigNumber } = require("bignumber.js");
+
+const subgraphs = {
+  "arbitrum": "https://api.studio.thegraph.com/query/16975/double-arbitrum/version/latest",
+}
+
+async function getTokens(chain) {
+  const graphQuery = `
+    {
+      assetTokens(where: {amount_gt: "0"}) {
+        tokenAddress
+      }
+      migrations(where: {pair_starts_with: "0x", lpAmount_gt: "0"}) {
+        pair
+        ammType
+      }
+      liquidities(where: {pair_starts_with: "0x", lpAmount_gt: "0"}) {
+        pair
+        ammType
+      }
+    }
+  `;
+
+  const { assetTokens, migrations, liquidities } = await cachedGraphQuery(`double2win/${chain}`, subgraphs[chain], graphQuery);
+
+  return { assetTokens, migrations, liquidities };
+}
+
+module.exports = {}
+
+Object.keys(config).forEach((network) => {
+  const networkConfig = config[network];
+
+  module.exports[network] = {
+    tvl: async (api) => {
+      // Initialize an empty map to store TVL per token
+      const block = api.block;
+      const tokenBalances = {};
+      const tokenData = await getTokens(network);
+      const pairAddresses = [];
+      tokenData.migrations.forEach(migration => {
+        pairAddresses.push(migration.pair.toLowerCase());
+      });
+      tokenData.liquidities.forEach(liquidity => {
+        pairAddresses.push(liquidity.pair.toLowerCase());
+      });
+      const assetAddresses = [];
+      tokenData.assetTokens.forEach(assetToken => {
+        assetAddresses.push(assetToken.tokenAddress.toLowerCase());
+      });
+      // Iterate over each contract type within the network
+      await Promise.all(
+        Object.keys(networkConfig).map(async (contractType) => {
+          const tokensAndOwners = [];
+          const { doubleContract, fromBlock, type } = networkConfig[contractType];
+          if (type.startsWith("v3")) {
+            await sumTokens2({ api, balances: tokenBalances, owner: doubleContract, resolveUniV3: true, chain: network, sumChunkSize: 50 })
+          } else {
+            if (type.startsWith("v2")) {
+              pairAddresses.forEach(pairAddress => {
+                tokensAndOwners.push([pairAddress, doubleContract]);
+              });
+              await sumTokens2({ api, balances: tokenBalances, tokensAndOwners: tokensAndOwners, chain: network, resolveLP: true, sumChunkSize: 50})
+            } else {
+              assetAddresses.forEach(asset => {
+                tokensAndOwners.push([asset, doubleContract]);
+              });
+              await sumTokens2({ api, balances: tokenBalances, tokensAndOwners: tokensAndOwners, chain: network, sumChunkSize: 50})
+            }
+          }
+        })
+      );
+      const balances = Object.fromEntries(
+        Object.entries(tokenBalances).filter(([_, value]) => !Number.isNaN(value))
+      );
+      const lpAddresses = [];
+      const finalBalances = balances;
+      transformAddress = await getChainTransform(network);
+      const { pairBalances, prices} = await getTokenPrices({ chain: network, block, lps: ["0x27D336a834775988b1305df42569E27128932bDD"],  useDefaultCoreAssets: true})
+      Object.entries(balances).forEach(([address, amount = 0]) => {
+        const token = stripTokenHeader(address)
+        const price = prices[token];
+        if (pairBalances[token]) {
+          lpAddresses.push(token)
+          return;
+        }
+        if (!price) return;
+        let tokenAmount = price[1] * +amount
+        const coreAsset = price[2]
+        sdk.util.sumSingleBalance(balances, transformAddress(coreAsset), BigNumber(tokenAmount).toFixed(0))
+        delete balances[address]
+      })
+
+      if (lpAddresses.length) {
+        const totalBalances = (await sdk.api.abi.multiCall({
+          abi: 'erc20:totalSupply', calls: lpAddresses.map(i => ({ target: i })), block, chain
+        })).output
+
+        totalBalances.forEach((item) => {
+          const token = item.input.target
+          const address = transformAddress(token)
+          const ratio = +item.output > 0 ? (+(balances[address]) || 0) / +item.output : 0
+          addBalances(pairBalances[token], finalBalances, { ratio, pairAddress: token, })
+          delete balances[address]
+        })
+      }
+      const fixBalances = await getFixBalances(network)
+      fixBalances(finalBalances)
+      return finalBalances
+    },
+  };
+});