add projects solvbtc bitcion network (DefiLlama#11474)

Co-authored-by: g1nt0ki <[email protected]>
Co-authored-by: qwen-solv <[email protected]>
Co-authored-by: hja <[email protected]>

Author: 4 people

projects/solv-protocol-funds/index.js

@@ -30,103 +30,24 @@ async function tvl(api) {
   await vaultBalance(api, graphData);
   await otherDeposit(api, address);
   await ceffuBalance(api, address, graphData);
-
-  return api.getBalances();
 }
 
-async function borrowed(api) {
-  const network = api.chain;
-
-  const graphData = await getGraphData(api.timestamp, network, api);
-  if (graphData.pools.length > 0) {
-    const poolLists = graphData.pools;
-
-    let address = (await getConfig('solv-protocol/funds', addressUrl));
-    const depositAddress = filterDepositAddress(network, address);
-
-    let fofFundPoolId = [];
-    if (address[network] && address[network]["fofFund"]) {
-      fofFundPoolId = address[network]["fofFund"];
-    }
-
-    let pools = [];
-    for (const pool of poolLists) {
-      if (depositAddress.length == 0 && depositAddress.indexOf(pool.vault) == -1 && fofFundPoolId.indexOf(pool.poolId) == -1) {
-        pools.push(pool);
-      }
-    }
-
-    const poolConcretes = await concrete(pools, api);
-    const nav = await api.multiCall({
-      abi: abi.getSubscribeNav,
-      calls: pools.map((index) => ({
-        target: index.navOracle,
-        params: [index.poolId, api.timestamp * 1000]
-      })),
-    })
-
-    const poolTotalValues = await api.multiCall({
-      abi: abi.slotTotalValue,
-      calls: pools.map((index) => ({
-        target: poolConcretes[index.contractAddress],
-        params: [index.openFundShareSlot]
-      })),
-    })
-
-    const poolBaseInfos = await api.multiCall({
-      abi: abi.slotBaseInfo,
-      calls: pools.map((index) => ({
-        target: poolConcretes[index.contractAddress],
-        params: [index.openFundShareSlot]
-      })),
-    })
-
-    const poolDecimalList = await api.multiCall({
-      abi: abi.decimals,
-      calls: poolBaseInfos.map(i => i[1]),
-    })
-
-    let vaults = {};
-    for (const key in pools) {
-      if (poolBaseInfos[key][1] && pools[key]["vault"]) {
-        vaults[`${pools[key]["vault"].toLowerCase()}-${poolBaseInfos[key][1].toLowerCase()}`] = [poolBaseInfos[key][1], pools[key]["vault"]]
-      }
-    }
-
-    const symbols = await api.multiCall({
-      abi: abi.symbol,
-      calls: poolBaseInfos.map((index) => ({
-        target: index[1]
-      })),
-    })
-
-    const balances = await api.multiCall({
-      abi: abi.balanceOf,
-      calls: Object.values(vaults).map((index) => ({
-        target: index[0],
-        params: [index[1]]
-      })),
-    })
+const solvbtcListUrl = 'https://raw.githubusercontent.com/solv-finance-dev/slov-protocol-defillama/main/solvbtc.json';
+async function getSolvBTCVAddresses(api) {
+  let solvbtc = (await getConfig('solv-protocol/solvbtc', solvbtcListUrl));
 
-    let vaultbalances = {};
-    for (let i = 0; i < Object.keys(vaults).length; i++) {
-      vaultbalances[Object.keys(vaults)[i]] = balances[i];
-    }
-    for (let i = 0; i < poolTotalValues.length; i++) {
-      const decimals = poolDecimalList[i];
-      let balance = BigNumber(poolTotalValues[i]).div(BigNumber(10).pow(18 - decimals)).times(BigNumber(nav[i].nav_).div(BigNumber(10).pow(decimals))).toNumber();
-      if (pools[i]['vault'] && poolBaseInfos[i][1] && vaultbalances[`${pools[i]['vault'].toLowerCase()}-${poolBaseInfos[i][1].toLowerCase()}`]) {
-        balance = BigNumber(balance).minus(vaultbalances[`${pools[i]['vault'].toLowerCase()}-${poolBaseInfos[i][1].toLowerCase()}`]).toNumber();
-        vaultbalances[`${pools[i]['vault'].toLowerCase()}-${poolBaseInfos[i][1].toLowerCase()}`] = undefined
-      }
-      if (balance > 0) {
-        if (symbols[i] !== "SolvBTC") {
-          api.add(poolBaseInfos[i][1], balance)
-        }
-      }
+  const blacklisted = {}
+  if (!solvbtc[api.chain] || !solvbtc[api.chain]["otherDeposit"]) {
+    return blacklisted
+  }
+  let otherDeposit = solvbtc[api.chain]["otherDeposit"];
+  for (const deposit of otherDeposit["depositAddress"]) {
+    for (const tokenAddress of otherDeposit["tokens"]) {
+      const key = `${tokenAddress}-${deposit}`.toLowerCase()
+      blacklisted[key] = true
     }
   }
-  return api.getBalances()
+  return blacklisted
 }
 
 async function otherDeposit(api, address) {
@@ -328,27 +249,17 @@ async function vaultBalance(api, graphData) {
         vaults[`${poolBaseInfos[key][1].toLowerCase()}-${poolLists[key]["vault"].toLowerCase()}`] = [poolBaseInfos[key][1], poolLists[key]["vault"]]
       }
     }
-
-    const symbols = await api.multiCall({
-      abi: abi.symbol,
-      calls: Object.values(vaults).map((index) => ({
-        target: index[0]
-      })),
+    const tokens = Object.values(vaults).map(([token]) => token)
+
+    const symbols = await api.multiCall({ abi: abi.symbol, calls: tokens, })
+    const blacklisted = await getSolvBTCVAddresses(api)
+    const blacklistedTokens = tokens.filter((token, i) => symbols[i].toLowerCase().includes('solvbtc'))
+    const tokensAndOwners = Object.values(vaults).filter(([token, owner]) => {
+      const key = `${token}-${owner}`.toLowerCase()
+      return !blacklisted[key] && !blacklistedTokens.includes(token)
     })
-
-    const balances = await api.multiCall({
-      abi: abi.balanceOf,
-      calls: Object.values(vaults).map((index) => ({
-        target: index[0],
-        params: [index[1]]
-      })),
-    })
-
-    for (const key in balances) {
-      if (symbols[key] !== "SolvBTC") {
-        api.add(Object.values(vaults)[key][0], balances[key])
-      }
-    }
+    
+    return api.sumTokens({ tokensAndOwners, blacklistedTokens, })
   }
 }
 
@@ -357,7 +268,7 @@ async function ceffuBalance(api, address, graphData) {
     return;
   }
   let ceffuData = address[api.chain]["ceffu"];
-  
+
   let pools = [];
   for (const graph of graphData.pools) {
     if (graph['openFundShareSlot'] == ceffuData['slot']) {
@@ -479,40 +390,10 @@ async function getGraphData(timestamp, chain, api) {
   };
 }
 
-function filterDepositAddress(network, address) {
-  let depositAddresses = [];
-  if (address[network]) {
-    if (address[network]["gm"]) {
-      for (let depositAddress of address[network]["gm"]["depositAddress"]) {
-        depositAddresses.push(depositAddress.toLowerCase())
-      }
-    }
-    if (address[network]["mux"]) {
-      depositAddresses.push(address[network]["mux"]["account"].toLowerCase())
-    }
-    if (address[network]["klp"]) {
-      for (let poolAddress of address[network]["klp"]["klpPool"]) {
-        depositAddresses.push(poolAddress.toLowerCase())
-      }
-    }
-    if (address[network]["iziswap"]) {
-      for (let owner of address[network]["iziswap"]["owner"]) {
-        depositAddresses.push(owner.toLowerCase())
-      }
-    }
-    if (address[network]["lendle"]) {
-      depositAddresses.push(address[network]["lendle"]["account"]["user"].toLowerCase())
-    }
-  }
-
-  return depositAddresses;
-}
-
 
 // node test.js projects/solv-protocol-funds
 ['ethereum', 'bsc', 'polygon', 'arbitrum', 'mantle', 'merlin'].forEach(chain => {
   module.exports[chain] = {
-    tvl,
-    borrowed
+    tvl
   }
 })

projects/solvbtc/index.js

@@ -1,7 +1,9 @@
 const abi = require("./abi.json");
+const sdk = require('@defillama/sdk');
 const { getConfig } = require("../helper/cache");
 const { cachedGraphQuery } = require("../helper/cache");
 const { sumTokens2, } = require("../helper/unwrapLPs");
+const { sumTokensExport, } = require('../helper/sumTokens');
 
 // The Graph
 const graphUrlList = {
@@ -14,30 +16,15 @@ const graphUrlList = {
 
 const solvbtcListUrl = 'https://raw.githubusercontent.com/solv-finance-dev/slov-protocol-defillama/main/solvbtc.json';
 
+const bitcionOwners = [
+  'bc1pjrxeuc9f3zqtx92s3mnf6202894jzufswur957l6s04rjns6dumsyh6u89',
+  'bc1qdpwl80flfh3k6h6sumzwgws3ephkrmx307hk64'
+]
+
 async function tvl(api) {
   let solvbtc = (await getConfig('solv-protocol/solvbtc', solvbtcListUrl));
 
-  await gm(api, solvbtc)
-  await vaultBalance(api, solvbtc);
   await otherDeposit(api, solvbtc);
-
-  return api.getBalances();
-}
-
-async function gm(api, solvbtc) {
-  if (!solvbtc[api.chain] || !solvbtc[api.chain]["gm"]) {
-    return;
-  }
-  let gm = solvbtc[api.chain]["gm"];
-
-  let tokens = []
-  for (const pool of gm["depositAddress"]) {
-    for (const address of gm["gmTokens"]) {
-      tokens.push({ address, pool })
-    }
-  }
-
-  await sumTokens2({ api, tokensAndOwners: tokens.map(i => [i.address, i.pool]), permitFailure: true });
 }
 
 async function otherDeposit(api, solvbtc) {
@@ -46,112 +33,25 @@ async function otherDeposit(api, solvbtc) {
   }
   let otherDeposit = solvbtc[api.chain]["otherDeposit"];
 
-  let tokens = []
+  let tokensAndOwners = []
   for (const deposit of otherDeposit["depositAddress"]) {
     for (const tokenAddress of otherDeposit["tokens"]) {
-      tokens.push({ tokenAddress, deposit })
+      tokensAndOwners.push([tokenAddress, deposit])
     }
   }
 
-  await sumTokens2({ api, tokensAndOwners: tokens.map(i => [i.tokenAddress, i.deposit]), permitFailure: true });
+  await sumTokens2({ api, tokensAndOwners, permitFailure: true });
 }
 
-async function concrete(slots, api) {
-  var slotsList = [];
-  var only = {};
-  for (var i = 0; i < slots.length; i++) {
-    if (!only[slots[i].contractAddress]) {
-      slotsList.push(slots[i]);
-      only[slots[i].contractAddress] = true;
-    }
-  }
-
-  const concreteLists = await api.multiCall({
-    calls: slotsList.map((index) => index.contractAddress),
-    abi: abi.concrete,
-  })
-
-  let concretes = {};
-  for (var k = 0; k < concreteLists.length; k++) {
-    concretes[slotsList[k].contractAddress] = concreteLists[k];
-  }
-
-  return concretes;
-}
-
-async function vaultBalance(api, solvbtc) {
-  if (!solvbtc[api.chain] || !solvbtc[api.chain]["slot"]) {
-    return;
-  }
-  let slot = solvbtc[api.chain]["slot"];
-
-  const graphData = await getGraphData(api.timestamp, api.chain, api, slot);
-  if (graphData.pools.length > 0) {
-    const poolLists = graphData.pools;
-
-    const poolConcretes = await concrete(poolLists, api);
-
-    const poolBaseInfos = await api.multiCall({
-      abi: abi.slotBaseInfo,
-      calls: poolLists.map((index) => ({
-        target: poolConcretes[index.contractAddress],
-        params: [index.openFundShareSlot]
-      })),
-    })
-
-    let vaults = {};
-    for (const key in poolLists) {
-      if (poolBaseInfos[key][1] && poolLists[key]["vault"]) {
-        vaults[`${poolBaseInfos[key][1].toLowerCase()}-${poolLists[key]["vault"].toLowerCase()}`] = [poolBaseInfos[key][1], poolLists[key]["vault"]]
-      }
+// node test.js projects/solvbtc
+['bitcoin', 'ethereum', 'bsc', 'polygon', 'arbitrum', 'mantle', 'merlin'].forEach(chain => {
+  if (chain == 'bitcoin') {
+    module.exports[chain] = {
+      tvl: sumTokensExport({ owners: bitcionOwners }),
     }
-
-    const balances = await api.multiCall({
-      abi: abi.balanceOf,
-      calls: Object.values(vaults).map((index) => ({
-        target: index[0],
-        params: [index[1]]
-      })),
-    })
-
-    for (const key in balances) {
-      api.add(Object.values(vaults)[key][0], balances[key])
+  } else {
+    module.exports[chain] = {
+      tvl
     }
   }
-}
-
-
-async function getGraphData(timestamp, chain, api, slot) {
-
-  const slotDataQuery = `query PoolOrderInfos {
-            poolOrderInfos(first: 1000  where:{fundraisingEndTime_gt:${timestamp}, openFundShareSlot_in: ${JSON.stringify(slot)}}) {
-              marketContractAddress
-              contractAddress
-              navOracle
-              poolId
-              vault
-              openFundShareSlot
-          }
-        }`;
-
-  let data;
-  if (graphUrlList[chain]) {
-    data = (await cachedGraphQuery(`solv-protocol/funds-graph-data/${chain}`, graphUrlList[chain], slotDataQuery, { api, }));
-  }
-
-  let poolList = [];
-  if (data != undefined && data.poolOrderInfos != undefined) {
-    poolList = data.poolOrderInfos;
-  }
-
-  return {
-    pools: poolList
-  };
-}
-
-// node test.js projects/solvbtc
-['ethereum', 'bsc', 'polygon', 'arbitrum', 'mantle', 'merlin'].forEach(chain => {
-  module.exports[chain] = {
-    tvl
-  }
 })