Merge branch 'master' of tol.github.com:DefiLlama/dimension-adapters

Author: treeoflife2

aggregators/liquidmesh/index.ts

@@ -19,17 +19,6 @@ const chainsMap: Record<string, string> = {
 	"tron": CHAIN.TRON,
 };
 
-const ExcludeTxns: Array<string> = [
-	'0x028cb1c81b8fefd8b9746e76e8e62ed3cfd7ad91e0bb3ef913f155299f562491',
-	'0x1ac7c39d9f9772e7e318e08057d69d71281caf2f837d7aacc9a7c848146d8b3a',
-	'0xbd76d7c9dbad2eaf565ee9140c118ad6182bf3fdb56ab3b00c4bb90426abded0',
-	'0xa51d62e0372ce52b73366efeda99473f4f57d8cb45bc27d4898ca41e1a933b79',
-	'0xf469df5649084d5028dce9037a055ab784e94ec2cb2f0f80c22b8e0101612194',
-	'0x6f8253da458212d0f2924a24df969561c7fdb134df310687ec200b720e769658',
-	'0x6ca69c2e57e67c07106c3f95700d8dfad9260f0c61ac19423a149f8f3ab471cd',
-	'0xe1d89b68828097d506e9dded1cc2e06742c42688ad51d99395aee640831bad4b',
-]
-
 const prefetch = async (options: FetchOptions): Promise<any> => {
 	// must exclude all blacklisted tokens
 	const ethereumBlacklistedTokens = getDefaultDexTokensBlacklisted(CHAIN.ETHEREUM)
@@ -48,7 +37,7 @@ const prefetch = async (options: FetchOptions): Promise<any> => {
 			AND evt_block_time < from_unixtime(${options.endTimestamp})
 			AND fromToken NOT IN (${allBlacklistedTokens.toString()})
 			AND toToken NOT IN (${allBlacklistedTokens.toString()})
-			AND evt_tx_hash NOT IN (${ExcludeTxns.toString()})
+			AND fromAmount < UINT256 '115792089237316195423570985008687907853269984665640564039457584007913129639935'
 		GROUP BY chain, fromToken
 	`)
 

bridge-aggregators/brotocol/index.ts

@@ -0,0 +1,63 @@
+import { FetchOptions, SimpleAdapter } from "../../adapters/types";
+import { CHAIN } from "../../helpers/chains";
+import fetchURL from "../../utils/fetchURL";
+
+interface ApiResponse {
+  day: string;
+  volume: number;
+}
+
+const chains: Record<string, string> = {
+  [CHAIN.AILAYER]: 'AILayer',
+  [CHAIN.ARBITRUM]: 'Arbitrum',
+  [CHAIN.AURORA]: 'Aurora',
+  [CHAIN.AVAX]: 'AVAX',
+  [CHAIN.BASE]: 'Base',
+  [CHAIN.BITCOIN]: 'Bitcoin',
+  [CHAIN.BITLAYER]: 'Bitlayer',
+  [CHAIN.BSC]: 'BNB',
+  [CHAIN.BOB]: 'BOB',
+  [CHAIN.BSQUARED]: 'Bsquared',
+  [CHAIN.CORE]: 'CORE',
+  [CHAIN.ETHEREUM]: 'Ethereum',
+  [CHAIN.LINEA]: 'Linea',
+  [CHAIN.MANTA]: 'Manta',
+  [CHAIN.MERLIN]: 'Merlin',
+  [CHAIN.MEZO]: 'Mezo',
+  [CHAIN.MODE]: 'MODE',
+  [CHAIN.SOLANA]: 'Solana',
+  [CHAIN.STACKS]: 'Stacks',
+  [CHAIN.XLAYER]: 'Xlayer',
+  
+  // dead chains
+  // [CHAIN.LORENZO]: 'Lorenzo',
+  // [CHAIN.RUNES]: 'Runes',
+  // [CHAIN.BRC20]: 'BRC20',
+};
+
+
+const api = "https://api.brotocol.xyz/v1/xlink/bridge-chain-volume-by-day"
+
+const fetch = async (_a: any, _b: any, options: FetchOptions) => {
+  const dateStr = new Date(options.startOfDay * 1000).toISOString().split('T')[0]
+  const data: ApiResponse = await fetchURL(`${api}?day=${dateStr}&chain=${chains[options.chain]}`)
+  return { dailyBridgeVolume: data.volume }
+}
+
+const adapter: SimpleAdapter = {
+  adapter: {
+    ...Object.entries(chains).reduce((acc, chain) => {
+      const [key, _] = chain;
+      return {
+        ...acc,
+        [key]: {
+          fetch,
+          runAtCurrTime: true,
+          // start: "2023-04-17",
+        },
+      };
+    }, {}),
+  },
+};
+
+export default adapter;

dexs/carbon/index.ts

@@ -1,13 +1,22 @@
 import request, { gql } from "graphql-request";
-import { FetchOptions, FetchResultVolume, SimpleAdapter } from "../../adapters/types";
+import {
+  FetchOptions,
+  FetchResultVolume,
+  SimpleAdapter,
+} from "../../adapters/types";
 import { CHAIN } from "../../helpers/chains";
 
-const baseEndpoint = "https://api.goldsky.com/api/public/project_cm0bho0j0ji6001t8e26s0wv8/subgraphs/intentx-base-analytics-083/latest/gn";
+const baseEndpoint =
+  "https://api.goldsky.com/api/public/project_cm0bho0j0ji6001t8e26s0wv8/subgraphs/intentx-base-analytics-083/latest/gn";
 
 const queryBase = gql`
   query stats($from: String!, $to: String!) {
     dailyHistories(
-      where: { timestamp_gte: $from, timestamp_lte: $to, accountSource: "0x8Ab178C07184ffD44F0ADfF4eA2ce6cFc33F3b86" }
+      where: {
+        timestamp_gte: $from
+        timestamp_lte: $to
+        accountSource: "0x39EcC772f6073242d6FD1646d81FA2D87fe95314"
+      }
     ) {
       tradeVolume
     }
@@ -20,7 +29,11 @@ interface IGraphResponse {
   }>;
 }
 
-const fetch = async (_a: any, _b: any, options: FetchOptions): Promise<FetchResultVolume> => {
+const fetch = async (
+  _a: any,
+  _b: any,
+  options: FetchOptions
+): Promise<FetchResultVolume> => {
   const response: IGraphResponse = await request(baseEndpoint, queryBase, {
     from: String(options.startTimestamp),
     to: String(options.endTimestamp),

fees/bend/index.ts

@@ -1,3 +1,4 @@
+import { request } from "graphql-request";
 import { FetchOptions, FetchV2, SimpleAdapter } from "../../adapters/types";
 import { CHAIN } from "../../helpers/chains";
 import { METRIC } from "../../helpers/metrics";
@@ -11,22 +12,38 @@ const CONFIG = {
 const methodology = {
   Fees: "Total borrow interest paid by borrowers + liquidation bonuses earned by liquidators.",
   SupplySideRevenue: "Total interests are distributed to suppliers/lenders + liquidation bonuses to liquidators.",
-  Revenue: "Total fees paid by borrowers from all markets and part of performance fee retained from all vaults.",
-  ProtocolRevenue: "No revenue for Bend protocol.",
+  Revenue: "Total interest paid by borrowers and part of performance fees share for Bend protocol.",
+  ProtocolRevenue: "Total interest paid by borrowers and part of performance fees share for Bend protocol.",
 }
 
-const MorphoBlueAbis = {
-  AccrueInterest: "event AccrueInterest(bytes32 indexed id, uint256 prevBorrowRate, uint256 interest, uint256 feeShares)",
-  Liquidate: "event Liquidate(bytes32 indexed id,address indexed caller,address indexed borrower,uint256 repaidAssets,uint256 repaidShares,uint256 seizedAssets,uint256 badDebtAssets,uint256 badDebtShares)",
-  CreateMarket: "event CreateMarket(bytes32 indexed id, tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams)",
-};
+const abi = {
+  morphoBlueFunctions: {
+    market: "function market(bytes32 input) returns (uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee)",
+    feeRecipient: "function feeRecipient() returns(address feeRecipient)"
+  },
+  metaMorphoFunctions: {
+    withdrawQueueLength: "function withdrawQueueLength() view returns (uint256)",
+    withdrawQueue: "function withdrawQueue(uint256 index) view returns (bytes32)",
+    asset: "function asset() view returns (address)",
+    convertToAssets: "function convertToAssets(uint256 shares) view returns (uint256)"
+  },
+  morphoBlueEvents: {
+    AccrueInterest: "event AccrueInterest(bytes32 indexed id, uint256 prevBorrowRate, uint256 interest, uint256 feeShares)",
+    CreateMarket: "event CreateMarket(bytes32 indexed id, tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams)",
+    Liquidate: "event Liquidate(bytes32 indexed id,address indexed caller,address indexed borrower,uint256 repaidAssets,uint256 repaidShares,uint256 seizedAssets,uint256 badDebtAssets,uint256 badDebtShares)"
+  },
+  metaMorphoEvents: {
+    Transfer: "event Transfer(address indexed from, address indexed to, uint256 value)"
+  }
+}
 
 type MorphoMarket = {
   marketId: string;
   loanAsset: string;
   collateralAsset?: string;
   lltv: bigint;
   lif: bigint;
+  fee: bigint;
 };
 
 type MorphoBlueAccrueInterestEvent = {
@@ -41,12 +58,26 @@ type MorphoBlueLiquidateEvent = {
   seizedAmount: bigint;
 };
 
+type PerformanceFee = {
+  token: string,
+  amount: bigint
+}
+
+type RewardVault = {
+  stakingTokenAddress: string
+}
+
+const BERACHAIN_API = "https://api.berachain.com";
+
+
 const toLowerKey = (id: string) => id.toLowerCase();
 
 const ONE = 10n ** 18n;
 
 const wMul = (x: bigint, y: bigint): bigint => (x * y / ONE);
 
+const ZERO_ADDRESS = '0x' + '0'.repeat(40);
+
 // https://docs.morpho.org/learn/concepts/liquidation/#liquidation-incentive-factor-lif
 function _getLIFFromLLTV(lltv: bigint): bigint {
   const B = BigInt(3e17) // 0.3
@@ -55,24 +86,46 @@ function _getLIFFromLLTV(lltv: bigint): bigint {
   return LIF > M ? M : LIF
 }
 
+const _getWhitelistedVaults = async () => {
+  const data = await request(BERACHAIN_API, `
+          {
+              polGetRewardVaults(where: {protocolsIn: ["Bend"], includeNonWhitelisted: false}) {
+                  vaults {
+                      stakingTokenAddress
+                  }
+              }
+          }
+      `);
+  return data.polGetRewardVaults.vaults.map((v: RewardVault) => v.stakingTokenAddress);
+}
+
 const fetchMarketsFromLogs = async (options: FetchOptions): Promise<Array<MorphoMarket>> => {
   const markets: Array<MorphoMarket> = [];
 
   const events = await options.getLogs({
     target: CONFIG.blue,
-    eventAbi: MorphoBlueAbis.CreateMarket,
+    eventAbi: abi.morphoBlueEvents.CreateMarket,
     fromBlock: CONFIG.fromBlock,
   });
 
-  for (const event of events) {
+  const marketIds = events.map(event => event.id)
+
+  const marketsInfo = await options.api.multiCall({
+    target: CONFIG.blue,
+    calls: marketIds,
+    abi: abi.morphoBlueFunctions.market,
+  });
+
+  events.forEach((event, idx) => {
     markets.push({
       marketId: event.id,
       loanAsset: event.marketParams.loanToken,
       collateralAsset: event.marketParams.collateralToken,
       lltv: BigInt(event.marketParams.lltv),
       lif: _getLIFFromLLTV(BigInt(event.marketParams.lltv)),
+      fee: BigInt(marketsInfo[idx]?.fee)
     })
-  }
+  })
 
   return markets;
 }
@@ -82,23 +135,24 @@ const fetchEvents = async (
 ): Promise<{ interests: Array<MorphoBlueAccrueInterestEvent>, liquidations: Array<MorphoBlueLiquidateEvent> }> => {
   let markets: Array<MorphoMarket> = await fetchMarketsFromLogs(options)
 
-
   const marketMap = {} as { [key: string]: MorphoMarket };
   markets.forEach((item) => {
     marketMap[item.marketId.toLowerCase()] = item;
   });
 
   const interests: Array<MorphoBlueAccrueInterestEvent> = (
     await options.getLogs({
-      eventAbi: MorphoBlueAbis.AccrueInterest,
+      eventAbi: abi.morphoBlueEvents.AccrueInterest,
       target: CONFIG.blue,
     })
   ).map((log: any) => {
     const key = toLowerKey(String(log.id));
     const market = marketMap[key];
 
     const interest = BigInt(log.interest);
-    const feeAmount = BigInt(log.feeShares);
+    const feeParam = market?.fee ?? 0n;
+
+    const feeAmount = wMul(interest, feeParam);
 
     return {
       token: market?.loanAsset ?? null,
@@ -110,7 +164,7 @@ const fetchEvents = async (
 
   const liquidations: Array<MorphoBlueLiquidateEvent> = (
     await options.getLogs({
-      eventAbi: MorphoBlueAbis.Liquidate,
+      eventAbi: abi.morphoBlueEvents.Liquidate,
       target: CONFIG.blue,
     })
   ).map((log) => {
@@ -129,12 +183,52 @@ const fetchEvents = async (
   return { interests, liquidations }
 };
 
+
+const fetchPerformanceFees = async (options: FetchOptions): Promise<Array<PerformanceFee>> => {
+  const vaults = await _getWhitelistedVaults();
+
+  const [feeRecipient, underlyingAssets] = await Promise.all(
+    [
+      options.api.call({
+        abi: abi.morphoBlueFunctions.feeRecipient,
+        target: CONFIG.blue,
+      }),
+      options.api.multiCall({
+        abi: abi.metaMorphoFunctions.asset,
+        calls: vaults,
+      }
+      )
+    ])
+
+  return Promise.all(vaults.map(async (v: string, idx: number) => {
+    const sharesAmount = (await options.getLogs({
+      target: v,
+      eventAbi: abi.metaMorphoEvents.Transfer,
+    }))
+      .filter(log => log[0] == ZERO_ADDRESS && log[1] == feeRecipient)
+      .map(log => log[2])
+      .reduce((totalAmount: bigint, value: bigint) => totalAmount + value, 0n);
+
+    const assetAmount = await options.api.call({
+      target: v,
+      abi: abi.metaMorphoFunctions.convertToAssets,
+      params: [sharesAmount]
+    })
+
+    return {
+      token: underlyingAssets[idx],
+      amount: assetAmount
+    } as PerformanceFee
+  }))
+}
+
 const fetch: FetchV2 = async (options: FetchOptions) => {
   const dailyFees = options.createBalances();
   const dailyRevenue = options.createBalances();
   const dailySupplySideRevenue = options.createBalances();
 
   const { interests, liquidations } = await fetchEvents(options);
+  const performanceFees = await fetchPerformanceFees(options)
 
   for (const event of interests) {
     if (!event.token) continue;
@@ -154,6 +248,11 @@ const fetch: FetchV2 = async (options: FetchOptions) => {
     dailySupplySideRevenue.add(event.token, bonus, METRIC.LIQUIDATION_FEES);
   }
 
+  for (const performanceFee of performanceFees) {
+    dailyFees.add(performanceFee.token, performanceFee.amount, METRIC.PERFORMANCE_FEES)
+    dailyRevenue.add(performanceFee.token, performanceFee.amount, METRIC.PERFORMANCE_FEES)
+  }
+
   return {
     dailyFees: dailyFees,
     dailySupplySideRevenue,
@@ -168,17 +267,20 @@ const adapter: SimpleAdapter = {
   breakdownMethodology: {
     Fees: {
       [METRIC.BORROW_INTEREST]: 'All interest paid by borrowers from all markets.',
+      [METRIC.PERFORMANCE_FEES]: 'Share of interest for Bend protocol paid by Vault curator.',
       [METRIC.LIQUIDATION_FEES]: 'All bonuses earned by liquidators from liquidations.',
     },
     Revenue: {
       [METRIC.BORROW_INTEREST]: 'Share of interest for Bend protocol.',
+      [METRIC.PERFORMANCE_FEES]: 'Share of interest for Bend protocol paid by Vault curator.',
     },
     SupplySideRevenue: {
       [METRIC.BORROW_INTEREST]: 'All interests paid are distributedd to vaults suppliers, lenders.',
       [METRIC.LIQUIDATION_FEES]: 'All bonuses earned by liquidators from liquidations.',
     },
     ProtocolRevenue: {
       [METRIC.BORROW_INTEREST]: 'Share of interest for Bend protocol.',
+      [METRIC.PERFORMANCE_FEES]: 'Share of interest for Bend protocol paid by Vault curator.',
     },
   },
   fetch: fetch,