add mode and bob

Author: dtmkeng

dexs/velodrome/index.ts

@@ -2,6 +2,7 @@ import { FetchOptions, SimpleAdapter } from "../../adapters/types";
 import { DEFAULT_DAILY_VOLUME_FIELD, DEFAULT_TOTAL_VOLUME_FIELD, getChainVolume } from "../../helpers/getUniSubgraphVolume";
 import { CHAIN } from "../../helpers/chains";
 import { Chain } from "@defillama/sdk/build/general";
+import { fetchV2Volume } from "./v2"
 
 const endpoints = {
   [CHAIN.OPTIMISM]: "https://api.thegraph.com/subgraphs/name/dmihal/velodrome",
@@ -20,6 +21,7 @@ const graphs = getChainVolume({
 });
 
 
+
 const fetch = (chain: Chain) => {
   return async (options: FetchOptions) => {
     const [v1] = await Promise.all([graphs(chain)(options)])
@@ -37,6 +39,14 @@ const adapter: SimpleAdapter = {
       fetch: fetch(CHAIN.OPTIMISM),
       start: 1677110400
     },
+    [CHAIN.MODE]: {
+      fetch: fetchV2Volume,
+      start: 1715763701
+    },
+    [CHAIN.BOB]: {
+      fetch: fetchV2Volume,
+      start: 1715763701
+    }
   },
 };
 

dexs/velodrome/v2.ts

@@ -0,0 +1,95 @@
+import { FetchOptions, FetchResult, FetchResultV2, SimpleAdapter } from "../../adapters/types"
+import { CHAIN } from "../../helpers/chains"
+
+const sugars = {
+  [CHAIN.MODE]: "0x207DfB36A449fd10d9c3bA7d75e76290a0c06731",
+  [CHAIN.BOB]: "0x3e71CCdf495d9628D3655A600Bcad3afF2ddea98"
+}
+const abis: any = {
+  "forSwaps": "function forSwaps(uint256 _limit, uint256 _offset) view returns ((address lp, int24 type, address token0, address token1, address factory, uint256 pool_fee)[])"
+}
+
+interface IForSwap {
+  lp: string;
+  type: string;
+  token0: string;
+  token1: string;
+  pool_fee: string;
+}
+
+interface ILog {
+  address: string;
+  data: string;
+  transactionHash: string;
+  topics: string[];
+}
+const event_swap = 'event Swap(address indexed sender,address indexed to,uint256 amount0In,uint256 amount1In,uint256 amount0Out,uint256 amount1Out)'
+const event_swap_slipstream = 'event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick)'
+
+const fetchV2Volume = async ({ api, getLogs, createBalances, chain }: FetchOptions): Promise<FetchResultV2> => {
+  const dailyVolume = createBalances()
+  const dailyFees = createBalances()
+  const chunkSize = 400;
+  let currentOffset = 0;
+  const allForSwaps: IForSwap[] = [];
+  let unfinished = true;
+
+while (unfinished) {
+    const forSwaps: IForSwap[] = (await api.call({
+    target: sugars[chain],
+    params: [chunkSize, currentOffset],
+    abi: abis.forSwaps,
+    chain: chain,
+    })).filter(t => Number(t.type) >= -1).map((e: any) => {
+    return {
+        lp: e.lp,
+        type: e.type,
+        token0: e.token0,
+        token1: e.token1,
+        pool_fee: e.pool_fee,
+    }
+    });
+
+    unfinished = forSwaps.length !== 0;
+    currentOffset += chunkSize;
+    allForSwaps.push(...forSwaps);
+}
+
+const targets = allForSwaps.map((forSwap: IForSwap) => forSwap.lp)
+
+const logs: ILog[][] = await getLogs({
+    targets,
+    eventAbi: event_swap,
+    flatten: false,
+})
+
+logs.forEach((logs: ILog[], idx: number) => {
+    const { token0, token1, pool_fee } = allForSwaps[idx]
+    logs.forEach((log: any) => {
+    dailyVolume.add(token0, BigInt(Math.abs(Number(log.amount0In))))
+    dailyVolume.add(token1, BigInt(Math.abs(Number(log.amount1In))))
+    dailyFees.add(token0, BigInt( Math.round((((Math.abs(Number(log.amount0In))) * Number(pool_fee)) / 10000)))) // 1% fee represented as pool_fee=100
+    dailyFees.add(token1, BigInt( Math.round((((Math.abs(Number(log.amount1In))) * Number(pool_fee)) / 10000))))
+    })
+})
+
+const slipstreamLogs: ILog[][] = await getLogs({
+    targets,
+    eventAbi: event_swap_slipstream,
+    flatten: false,
+})
+
+slipstreamLogs.forEach((logs: ILog[], idx: number) => {
+    const { token1, pool_fee } = allForSwaps[idx]
+    logs.forEach((log: any) => {
+    dailyVolume.add(token1, BigInt(Math.abs(Number(log.amount1))))
+    dailyFees.add(token1, BigInt( Math.round((((Math.abs(Number(log.amount1))) * Number(pool_fee)) / 1000000)))) // 1% fee represented as pool_fee=10000 for Slipstream
+    })
+})
+
+return { dailyVolume, dailyFees, dailyRevenue: dailyFees, dailyHoldersRevenue: dailyFees }
+}
+
+export {
+  fetchV2Volume
+}

fees/velodrome/index.ts

@@ -1,6 +1,7 @@
 import { Adapter, FetchOptions, FetchResultFees } from '../../adapters/types';
-import { OPTIMISM } from '../../helpers/chains';
+import { CHAIN, OPTIMISM } from '../../helpers/chains';
 import { fetchV1 } from './velodrome';
+import { fetchFees } from "./v2"
 
 
 const getFees = async (options: FetchOptions) => {
@@ -22,6 +23,14 @@ const adapter: Adapter = {
       fetch: getFees,
       start: 1677110400, // TODO: Add accurate timestamp
     },
+    [CHAIN.MODE]: {
+      fetch: fetchFees,
+      start: 1715763701
+    },
+    [CHAIN.BOB]: {
+      fetch: fetchFees,
+      start: 1715763701
+    }
   },
 };
 export default adapter;

fees/velodrome/v2.ts

@@ -0,0 +1,73 @@
+import { Balances } from "@defillama/sdk";
+import { FetchOptions, FetchResultFees } from "../../adapters/types";
+import { CHAIN } from "../../helpers/chains";
+import { getDexFees } from "../../helpers/dexVolumeLogs";
+
+const event_notify_reward = 'event NotifyReward(address indexed from,uint256 amount)';
+const event_geuge_created = 'event StakingRewardsCreated(address indexed pool,address indexed rewardToken,address indexed stakingRewards,address creator)'
+
+const abis: any = {
+  "forSwaps": "function forSwaps(uint256 _limit, uint256 _offset) view returns ((address lp, int24 type, address token0, address token1, address factory, uint256 pool_fee)[])"
+}
+const sugars: any = {
+  [CHAIN.MODE]: "0x207DfB36A449fd10d9c3bA7d75e76290a0c06731",
+  [CHAIN.BOB]: "0x3e71CCdf495d9628D3655A600Bcad3afF2ddea98"
+}
+
+const stakingRewards = {
+  [CHAIN.MODE]: "0xD2F998a46e4d9Dd57aF1a28EBa8C34E7dD3851D7",
+  [CHAIN.BOB]: "0x8Eb6838B4e998DA08aab851F3d42076f21530389"
+}
+const rewardTokens = {
+  [CHAIN.MODE]: "0xDfc7C877a950e49D2610114102175A06C2e3167a",
+  [CHAIN.BOB]: "0x4200000000000000000000000000000000000006"
+}
+
+export const fees_bribes = async ({ getLogs, createBalances, getToBlock, chain }: FetchOptions): Promise<Balances> => {
+  const stakingRewardsFactory = stakingRewards[chain] ;
+  const rewardToken = rewardTokens[chain];
+  const dailyFees = createBalances()
+  const logs_geuge_created = (await getLogs({
+    target: stakingRewardsFactory,
+    fromBlock: 7797181,
+    toBlock: await getToBlock(),
+    eventAbi: event_geuge_created,
+  }))
+  const bribes_contract: string[] = logs_geuge_created.map((e: any) => e.stakingRewards.toLowerCase());
+  if (bribes_contract.length === 0) {
+    return dailyFees;
+  }
+  const logs = await getLogs({
+    targets: bribes_contract,
+    eventAbi: event_notify_reward,
+  })
+  logs.map((e: any) => {
+    dailyFees.add(rewardToken, e.amount)
+  })
+  return dailyFees;
+}
+
+const fetchFees = async (options: FetchOptions): Promise<FetchResultFees> => {
+  const chunkSize = 500;
+  let currentOffset = 0;
+  let unfinished = true;
+  const allPools: any[] = [];
+
+  if (options.startOfDay > 1715763701) { // Sugar pools data helper contract created at this timestamp
+    while (unfinished) {
+      const allPoolsChunk = await options.api.call({ target: sugars[options.chain], abi: abis.forSwaps, params: [chunkSize, currentOffset], chain: options.chain})
+      unfinished = allPoolsChunk.length !== 0;
+      currentOffset += chunkSize;
+      allPools.push(...allPoolsChunk);
+    }
+  }
+
+  const pools = allPools.map((e: any) => e.lp)
+  const res: any = await getDexFees({ chain: options.chain, fromTimestamp: options.fromTimestamp, toTimestamp: options.toTimestamp, pools, timestamp: options.startOfDay, fetchOptions: options })
+  res.dailyBribesRevenue = await fees_bribes(options);
+  return res;
+}
+
+export {
+  fetchFees
+}

helpers/chains.ts

@@ -149,7 +149,8 @@ export enum CHAIN {
   BITLAYER = "bitlayer",
   XLAYER = "xlayer",
   MERLIN = "merlin",
-  CHILIZ = "chiliz"
+  CHILIZ = "chiliz",
+  BOB = "bob",
 }
 
 // Don´t use