Merge branch 'main' of github.com:Thesauros/DefiLlama-Adapters

PillarDevelopment · PillarDevelopment · commit 39885eeb293f · 2025-12-15T11:49:35.000+03:00
diff --git a/projects/helper/chains.json b/projects/helper/chains.json
@@ -161,6 +161,7 @@
   "flow",
   "fluence",
   "formnetwork",
+  "fogo",
   "fraxtal",
   "fsc",
   "ftn",
diff --git a/projects/helper/env.js b/projects/helper/env.js
@@ -26,6 +26,7 @@ const DEFAULTS = {
   SUBSCAN_API_KEY: 'ca3ba5ed1ff44b689c5f81dfc6b1644b',
   RENEC_RPC: "https://api-mainnet-beta.renec.foundation:8899/",
   FLOW_RPC: 'https://rest-mainnet.onflow.org',
+  FOGO_RPC: 'https://mainnet.fogo.io',
   CAMP_RPC: 'https://rpc.camp.raas.gelato.cloud',
   LULO_API_KEY: '',
   TRON_RPC: 'https://api.trongrid.io',
diff --git a/projects/helper/svmChainConfig.js b/projects/helper/svmChainConfig.js
@@ -14,6 +14,7 @@ const endpointMap = {
   soon: () => getEnv('SOON_RPC'),
   soon_base: () => getEnv('SOON_BASE_RPC'),
   soon_bsc: () => getEnv('SOON_BSC_RPC'),
+  fogo: () => getEnv('FOGO_RPC'),
 }
 const svmChains = Object.keys(endpointMap)
 
diff --git a/projects/helper/tokenMapping.js b/projects/helper/tokenMapping.js
@@ -79,7 +79,11 @@ const fixBalancesTokens = {
   stable: {
     '0x779Ded0c9e1022225f8E0630b35a9b54bE713736': { coingeckoId: 'usdt0', decimals: 6 },
     '0x0000000000000000000000000000000000001003': { coingeckoId: 'usdt0', decimals: 18 },
-  }
+  },
+  fogo: {
+    'uSd2czE61Evaf76RNbq4KPpXnkiL3irdzgLFUMe3NoG': { coingeckoId: 'usd-coin', decimals: 6 },
+    'HLc5hqihQGFU68488j7HkdyF6rywyJfV46BN6Dn8W5ug': { coingeckoId: 'solana', decimals: 8 },
+  },
 }
 
 ibcChains.forEach(chain => fixBalancesTokens[chain] = { ...ibcMappings, ...(fixBalancesTokens[chain] || {}) })
diff --git a/projects/kinetiq-markets/index.js b/projects/kinetiq-markets/index.js
@@ -1,11 +1,7 @@
-const ADDRESSES = require('../helper/coreAssets.json')
-const { getLogs } = require('../helper/cache/getLogs')
+const router = '0x6AB31532382Ba5cD5E8b5D343Cf5995906bb8DD8'
 
-const WHYPE = ADDRESSES.hyperliquid.WHYPE
-const ROUTER = '0x6AB31532382Ba5cD5E8b5D343Cf5995906bb8DD8'
-const KHYPE_MANAGER = '0x393D0B87Ed38fc779FD9611144aE649BA6082109'
-
-const FROM_BLOCK = 4800000
+const HYPE = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'
+const kHypeManager = '0x393D0B87Ed38fc779FD9611144aE649BA6082109'
 
 const abis = {
   phase: "function phase(address exManager) view returns (uint8)",
@@ -15,115 +11,62 @@ const abis = {
   nextWithdrawalId: "function nextWithdrawalId(address) view returns (uint256)",
   withdrawalDelay: "function withdrawalDelay() view returns (uint256)",
   withdrawalRequests: "function withdrawalRequests(address user, uint256 id) view returns (uint256 hypeAmount, uint256 kHYPEAmount, uint256 kHYPEFee, uint256 bufferUsed, uint256 timestamp)",
-}
-
-const eventAbi = "event ExManagerRegistered(address indexed exManager, address indexed exLST)"
+};
 
-const DEFAULT_MANAGERS = [
-  '0x4ef8bbacee867efd6faa684b30ecd12df74c4a48'
+const managers = [
+  '0x4ef8bbacee867efd6faa684b30ecd12df74c4a48' // kmHYPE
 ]
 
-async function getExchangeManagers(api) {
-  try {
-    const logs = await getLogs({
-      api,
-      target: ROUTER,
-      eventAbi,
-      fromBlock: FROM_BLOCK,
-      onlyArgs: true,
-    })
-    if (logs.length > 0) {
-      return logs.map(log => log.exManager)
-    }
-  } catch (e) {
-    // Fall back to known managers
-  }
-  return DEFAULT_MANAGERS
-}
-
-async function tvl(api) {
-  const managers = await getExchangeManagers(api)
-
+const tvl = async (api) => {
   const [phases, exLSTs] = await Promise.all([
-    api.multiCall({ target: ROUTER, calls: managers, abi: abis.phase }),
-    api.multiCall({ target: ROUTER, calls: managers, abi: abis.exLST }),
+    api.multiCall({ target: router, calls: managers, abi: abis.phase }),
+    api.multiCall({ target: router, calls: managers, abi: abis.exLST }),
   ])
 
   for (const [index, exLST] of exLSTs.entries()) {
-    if (!exLST || exLST === ADDRESSES.null) continue
-
     const phase = phases[index]
     const manager = managers[index]
 
     const supply = await api.call({ target: exLST, abi: 'erc20:totalSupply' })
-    if (!supply || supply === '0') continue
-
-    const allowedAssets = await api.call({
-      target: ROUTER,
-      params: [phase],
-      abi: abis.allowedTokensInOnDeposit,
-      permitFailure: true
-    })
+    const allowedAssets = await api.call({ target: router, params: phase, abi: abis.allowedTokensInOnDeposit, permitFailure: true })
 
     if (!allowedAssets?.length) continue
 
     const assetOutputs = await api.multiCall({
       abi: abis.exLstToTokenOut,
       permitFailure: true,
-      calls: allowedAssets.map((asset) => ({
-        target: ROUTER,
-        params: [manager, asset, supply]
-      })),
+      calls: allowedAssets.map((asset) => ({ target: router, params: [manager, asset, supply] })),
     })
 
-    for (let i = 0; i < allowedAssets.length; i++) {
-      const asset = allowedAssets[i]
+    allowedAssets.forEach((asset, i) => {
       const amount = assetOutputs[i]
+      if (!amount) return
+      api.add(asset, amount)
+    })
 
-      if (!amount || amount === '0') continue
-
-      if (asset.toLowerCase() === WHYPE.toLowerCase() ||
-          asset.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
-        api.add(WHYPE, amount)
-        break
-      }
-    }
-
-    try {
-      const [nextWithdrawalId, withdrawalDelay] = await Promise.all([
-        api.call({ target: KHYPE_MANAGER, params: [manager], abi: abis.nextWithdrawalId }),
-        api.call({ target: KHYPE_MANAGER, abi: abis.withdrawalDelay })
-      ])
+    const [nextWithdrawalId, withdrawalDelay] = await Promise.all([
+      api.call({ target: kHypeManager, params: [manager], abi: abis.nextWithdrawalId }),
+      api.call({ target: kHypeManager, abi: abis.withdrawalDelay })
+    ])
 
-      if (nextWithdrawalId && Number(nextWithdrawalId) > 0) {
-        const withdrawalIds = [...Array(Math.min(Number(nextWithdrawalId), 100)).keys()]
+    const withdrawalIds = [...Array(Number(nextWithdrawalId)).keys()]
 
-        const withdrawalRequests = await api.multiCall({
-          target: KHYPE_MANAGER,
-          abi: abis.withdrawalRequests,
-          calls: withdrawalIds.map((id) => ({ params: [manager, id] })),
-          permitFailure: true,
-        })
+    const withdrawalRequests = await api.multiCall({
+      target: kHypeManager,
+      abi: abis.withdrawalRequests,
+      calls: withdrawalIds.map((id) => ({ params: [manager, id] })),
+      permitFailure: true,
+    })
 
-        const now = api.timestamp || Math.floor(Date.now() / 1000)
+    if (!withdrawalRequests.length) continue
+    const now = Math.floor(Date.now() / 1000)
 
-        withdrawalRequests.forEach((req) => {
-          if (!req) return
-          const { hypeAmount, timestamp } = req
-          if (now >= Number(timestamp) + Number(withdrawalDelay)) {
-            api.add(WHYPE, -BigInt(hypeAmount))
-          }
-        })
-      }
-    } catch (e) {
-      // Continue without withdrawal adjustment
-    }
+    withdrawalRequests.forEach(({ hypeAmount, timestamp }) => {
+      now < Number(timestamp) + Number(withdrawalDelay) ? api.add(HYPE, -hypeAmount) : api.add(HYPE, -0)
+    })
   }
 }
 
 module.exports = {
-  doublecounted: true,
-  timetravel: false,
-  methodology: 'TVL is calculated from the total exLST supply converted to underlying HYPE value via router functions.',
   hyperliquid: { tvl }
-}
+}
diff --git a/projects/ribbon-earn/index.js b/projects/ribbon-earn/index.js
@@ -1,50 +1,28 @@
 const ADDRESSES = require('../helper/coreAssets.json')
 const sdk = require("@defillama/sdk")
-const abi = require("../ribbon/abi.json")
 const { sumTokensExport } = require('../helper/unwrapLPs');
-const { default: BigNumber } = require("bignumber.js");
 
 // Ribbon Earn vaults
 const rearnUSDC = "0x84c2b16FA6877a8fF4F3271db7ea837233DFd6f0";
 const rearnstETH = "0xCE5513474E077F5336cf1B33c1347FDD8D48aE8c";
 
-// Ethereum Assets
-const usdc = ADDRESSES.ethereum.USDC;
-const steth = ADDRESSES.ethereum.STETH;
+const tokensAndOwners = [
+  [ADDRESSES.ethereum.USDC, rearnUSDC],
+  [ADDRESSES.ethereum.STETH, rearnstETH],
+]
 
-async function addVaults({ balances, chain, vaults, block, transformAddress = a => a }) {
-  const { output: balanceRes } = await sdk.api.abi.multiCall({
-    abi: abi.totalBalance,
-    calls: vaults.map(i => ({ target: i[1]})),
-    chain, block,
-  })
-
-  balanceRes.forEach((data, i) => sdk.util.sumSingleBalance(balances, transformAddress(vaults[i][0]), data.output))
-}
-
-async function getAssetOnVault(asset, param, block) {
-  const { output: balance } = await sdk.api.abi.call({
-    target: asset, abi: 'erc20:balanceOf', params: param, block,
-  })
-  return balance
-}
-
-async function borrowed(_, block) {
-  const balances = {};
-  const vaults = [
-    // ribbon earn
-    [usdc, rearnUSDC],
-    [steth, rearnstETH],
-  ]
-  await addVaults({ balances, block, vaults, })
-  sdk.util.sumSingleBalance(balances, usdc, BigNumber(-1 * (await getAssetOnVault(usdc, rearnUSDC, block))).toFixed(0))
-  sdk.util.sumSingleBalance(balances, steth, BigNumber(-1 * (await getAssetOnVault(steth, rearnstETH, block))).toFixed(0))
-  return balances
+async function borrowed(api) {
+  const cloneApi = new sdk.ChainApi({ block: api.block, chain: api.chain });
+  await cloneApi.sumTokens({ tokensAndOwners })
+  const bals = await api.multiCall({ abi: 'uint256:totalBalance', calls: tokensAndOwners.map(i => i[1]) })
+  const tokens = tokensAndOwners.map(i => i[0])
+  api.add(tokens, bals)
+  api.getBalancesV2().subtract(cloneApi.getBalances())
 }
 
 module.exports = {
   ethereum: {
-    tvl: sumTokensExport({tokensAndOwners: [[usdc, rearnUSDC], [steth, rearnstETH]]}),
+    tvl: sumTokensExport({ tokensAndOwners }),
     borrowed,
   },
 }
diff --git a/projects/ribbon/evm.js b/projects/ribbon/evm.js
@@ -50,13 +50,6 @@ const wavax = ADDRESSES.avax.WAVAX;
 const savax = ADDRESSES.avax.SAVAX;
 const usdce = ADDRESSES.avax.USDC_e;
 
-async function addVaults({ vaults, api }) {
-  const tokens = vaults.map(i => i[0])
-  const calls = vaults.map(i => i[1])
-  const balance = await api.multiCall({ abi: 'uint256:totalBalance', calls })
-  api.add(tokens, balance)
-}
-
 async function ethTvl(api) {
   const vaults = [
     // theta vault
@@ -80,8 +73,7 @@ async function ethTvl(api) {
     [badger, badgerCallVault],
 
   ]
-
-  await addVaults({ api, vaults, })
+  await api.sumTokens({ tokensAndOwners: vaults })
   // pauser holds a variety of coins
   return sumTokens2({ api, owner: pauserEth, tokens: [nullAddress, usdc, wbtc, steth, aave,], })
 }
@@ -93,7 +85,7 @@ async function avaxTvl(api) {
     [usdce, usdcAvaxPutVault],
   ]
 
-  await addVaults({ api, vaults, })
+  await api.sumTokens({ tokensAndOwners: vaults })
   return sumTokens2({ owner: pauserAvax, tokens: [nullAddress, savax], api, })
 }
 
diff --git a/projects/valiant-trade/index.js b/projects/valiant-trade/index.js
@@ -0,0 +1,84 @@
+const { sumTokens2, getProvider, } = require("../helper/solana");
+const { Program } = require("@project-serum/anchor");
+const DEX_PROGRAM_ID = 'vnt1u7PzorND5JjweFWmDawKe2hLWoTwHU6QKz6XX98'
+
+
+async function tvl(api) {
+  const provider = getProvider(api.chain);
+  const program = new Program(idl, DEX_PROGRAM_ID, provider)
+
+  const tokenAccounts = (await program.account.vortex.all())
+    .map(({ account }) => [account.tokenVaultA, account.tokenVaultB])
+    .flat();
+
+  return sumTokens2({ tokenAccounts, api });
+}
+
+module.exports = {
+  timetravel: false,
+  fogo: {
+    tvl,
+  }
+}
+
+const idl = {
+  "version": "0.3.4",
+  "name": "vortex",
+  "instructions": [],
+  "accounts": [
+    {
+      "name": "Vortex",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          { "name": "vortexConfig", "type": "publicKey" },
+          { "name": "vortexBump", "type": { "array": ["u8", 1] } },
+          { "name": "tickSpacing", "type": "u16" },
+          { "name": "tickSpacingSeed", "type": { "array": ["u8", 2] } },
+          { "name": "feeRate", "type": "u16" },
+          { "name": "protocolFeeRate", "type": "u16" },
+          { "name": "liquidity", "type": "u128" },
+          { "name": "sqrtPrice", "type": "u128" },
+          { "name": "tickCurrentIndex", "type": "i32" },
+          { "name": "protocolFeeOwedA", "type": "u64" },
+          { "name": "protocolFeeOwedB", "type": "u64" },
+          { "name": "tokenMintA", "type": "publicKey" },
+          { "name": "tokenVaultA", "type": "publicKey" },
+          { "name": "feeGrowthGlobalA", "type": "u128" },
+          { "name": "tokenMintB", "type": "publicKey" },
+          { "name": "tokenVaultB", "type": "publicKey" },
+          { "name": "feeGrowthGlobalB", "type": "u128" },
+          { "name": "rewardLastUpdatedTimestamp", "type": "u64" },
+          { "name": "rewardInfos", "type": { "array": [{ "defined": "VortexRewardInfo" }, 3] } }
+        ]
+      }
+    }
+  ],
+  "types": [
+    {
+      "name": "VortexRewardInfo",
+      "docs": [
+        "Stores the state relevant for tracking liquidity mining rewards at the `Vortex` level.",
+        "These values are used in conjunction with `PositionRewardInfo`, `Tick.reward_growths_outside`,",
+        "and `Vortex.reward_last_updated_timestamp` to determine how many rewards are earned by open",
+        "positions."
+      ],
+      "type": {
+        "kind": "struct",
+        "fields": [
+          { "name": "mint", "docs": ["Reward token mint."], "type": "publicKey" },
+          { "name": "vault", "docs": ["Reward vault token account."], "type": "publicKey" },
+          { "name": "authority", "docs": ["Authority account that has permission to initialize the reward and set emissions."], "type": "publicKey" },
+          { "name": "emissionsPerSecondX64", "docs": ["Q64.64 number that indicates how many tokens per second are earned."], "type": "u128" },
+          {
+            "name": "growthGlobalX64",
+            "docs": ["Q64.64 number that tracks the total tokens earned per unit of liquidity since the reward", "emissions were turned on."],
+            "type": "u128"
+          }
+        ]
+      }
+    }
+  ],
+  "events": [],
+  "errors": []
+}
diff --git a/projects/vishwa/index.js b/projects/vishwa/index.js

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ const endpointMap = {`
`14`	`14`	`soon: () => getEnv('SOON_RPC'),`
`15`	`15`	`soon_base: () => getEnv('SOON_BASE_RPC'),`
`16`	`16`	`soon_bsc: () => getEnv('SOON_BSC_RPC'),`
	`17`	`+ fogo: () => getEnv('FOGO_RPC'),`
`17`	`18`	`}`
`18`	`19`	`const svmChains = Object.keys(endpointMap)`
`19`	`20`