Small cleanup dexVolumes folder (DefiLlama#3443)

* Add .vscode folder to .gitignore

* Add v0 test script

* Fix types

* Fix chain blocks type

* Change dex volumes readme

* Fix ts errors

* Remove workbench.colorCustomizations

* Finally fix ts errors

* Chore test script

* Revert "Remove workbench.colorCustomizations"

This reverts commit 8e87210.

* Revert back since it doesn't solve the issue

* Upgrade trilom/file-changes-action from 1.2.3 -> 1.2.4

.github/workflows/test.yml

@@ -6,7 +6,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - id: file_changes
-        uses: trilom/[email protected].3
+        uses: trilom/[email protected].4
         with:
           output: 'json'
           fileOutput: 'json'

.gitignore

@@ -8,3 +8,4 @@ historical-data.js
 yarn.lock
 .DS_Store
 projects/pooltogether/index.js
+.vscode

dexVolumes/README.md

@@ -0,0 +1,7 @@
+# DEX volumes
+
+> **_NOTE:_** Under developement.
+
+## Test an adapter
+
+`npm run test-dex 1inch`

dexVolumes/cli/testAdapter.ts

@@ -0,0 +1,63 @@
+import * as path from 'path'
+import type { ChainBlocks, DexAdapter, VolumeAdapter } from '../dexVolume.type';
+import { chainsForBlocks } from "@defillama/sdk/build/computeTVL/blocks";
+import { Chain } from '@defillama/sdk/build/general';
+import handleError from '../../utils/handleError';
+import { checkArguments, getLatestBlockRetry, printVolumes } from './utils';
+
+// Add handler to rejections/exceptions
+process.on('unhandledRejection', handleError)
+process.on('uncaughtException', handleError)
+
+// Check if all arguments are present
+checkArguments(process.argv)
+
+// Get path of module import
+const passedFile = path.resolve(process.cwd(), `dexVolumes/${process.argv[2]}`);
+(async () => {
+  console.info(`Running ${process.argv[2].toUpperCase()} adapter`)
+  // Import module to test
+  let module: DexAdapter = (await import(passedFile)).default
+
+  if ("volume" in module) {
+    // Get adapter
+    const volumeAdapter = module.volume
+    const volumes = await runAdapter(volumeAdapter)
+    printVolumes(volumes)
+  } else if ("breakdown" in module) {
+    const breakdownAdapter = module.breakdown
+    const allVolumes = await Promise.all(Object.entries(breakdownAdapter).map(async ([version, adapter]) =>
+      await runAdapter(adapter).then(res => ({ version, res }))
+    ))
+    allVolumes.forEach((promise) => {
+      console.info(promise.version)
+      printVolumes(promise.res)
+    })
+  } else console.info("No compatible adapter found")
+})()
+
+async function runAdapter(volumeAdapter: VolumeAdapter) {
+  // Get chains to check
+  const chains = Object.keys(volumeAdapter).filter(item => typeof volumeAdapter[item] === 'object');
+  // Get lastest block 
+  const chainBlocks: ChainBlocks = {};
+  await Promise.all(
+    chains.map(async (chainRaw) => {
+      const chain: Chain = chainRaw === "ava" ? "avax" : chainRaw as Chain
+      if (chainsForBlocks.includes(chain as Chain) || chain === "ethereum") {
+        const latestBlock = await getLatestBlockRetry(chain)
+        if (!latestBlock) throw new Error("latestBlock")
+        chainBlocks[chain] = latestBlock.number - 10
+      }
+    })
+  );
+  // Get volumes
+  const unixTimestamp = Math.round(Date.now() / 1000) - 60;
+  const volumes = await Promise.all(Object.keys(chainBlocks).map(
+    async chain => volumeAdapter[chain].fetch(unixTimestamp, chainBlocks)
+      .then(res => {
+        return { timestamp: unixTimestamp, totalVolume: res.totalVolume, dailyVolume: res.dailyVolume }
+      })
+  ))
+  return volumes
+}

dexVolumes/cli/utils.ts

@@ -0,0 +1,29 @@
+import { getLatestBlock } from "@defillama/sdk/build/util";
+import { FetchResult } from "../dexVolume.type";
+
+export function checkArguments(argv: string[]) {
+    if (argv.length < 3) {
+        console.error(`Missing argument, you need to provide the filename of the adapter to test.
+    Eg: ts-node dexVolumes/cli/testAdapter.js dexVolumes/myadapter.js`);
+        process.exit(1);
+    }
+}
+
+export async function getLatestBlockRetry(chain: string) {
+    for (let i = 0; i < 5; i++) {
+        try {
+            return await getLatestBlock(chain);
+        } catch (e) {
+            throw new Error(`Couln't get block heights for chain "${chain}"\n${e}`);
+        }
+    }
+}
+
+export function printVolumes(volumes: FetchResult[]) {
+    volumes.forEach(element => {
+        console.info("----------")
+        console.info(`Daily: ${element.dailyVolume}`)
+        console.info(`Total: ${element.totalVolume}`)
+        console.info("----------")
+      });
+}

dexVolumes/dexVolume.type.ts

@@ -1,5 +1,5 @@
 export type ChainBlocks = {
-  [x: string]: number;
+  [x: string]: number
 };
 
 export type FetchResult = {

dexVolumes/helper/getStartTimestamp.ts

@@ -0,0 +1,46 @@
+import { request, gql } from "graphql-request";
+
+import { DEFAULT_DAILY_VOLUME_FACTORY, DEFAULT_DAILY_VOLUME_FIELD } from "./getUniSubgraphVolume";
+
+interface IGetStartTimestamp {
+  endpoints: {
+    [chain: string]: string;
+  }
+  chain: string
+  dailyDataField: string
+  volumeField: string
+  dateField?: string
+  first?: number
+}
+
+const getStartTimestamp =
+  ({
+    endpoints,
+    chain,
+    dailyDataField = `${DEFAULT_DAILY_VOLUME_FACTORY}s`,
+    volumeField = DEFAULT_DAILY_VOLUME_FIELD,
+    dateField = "date",
+    first = 1000,
+  }: IGetStartTimestamp) =>
+    async () => {
+      const query = gql`
+        {
+            ${dailyDataField}(first: ${first}) {
+                ${dateField}
+                ${volumeField}
+            }
+        }
+    `;
+
+      const result = await request(endpoints[chain], query);
+
+      const days = result?.[dailyDataField];
+
+      const firstValidDay = days.find((data: any) => data[volumeField] !== "0");
+
+      return firstValidDay[dateField];
+    };
+
+export {
+  getStartTimestamp,
+};

dexVolumes/helper/getUniSubgraphVolume.js → dexVolumes/helper/getUniSubgraphVolume.ts

@@ -1,5 +1,7 @@
-const { request, gql } = require("graphql-request");
-const { getBlock } = require("./getBlock");
+import { Chain } from "@defillama/sdk/build/general";
+import { request, gql } from "graphql-request";
+import { getBlock } from "../../projects/helper/getBlock";
+import { ChainBlocks } from "../dexVolume.type";
 
 const getUniqStartOfTodayTimestamp = (date = new Date()) => {
   var date_utc = Date.UTC(
@@ -11,7 +13,7 @@ const getUniqStartOfTodayTimestamp = (date = new Date()) => {
     date.getUTCSeconds()
   );
   var startOfDay = new Date(date_utc);
-  var timestamp = startOfDay / 1000;
+  var timestamp = startOfDay.getTime() / 1000;
   return Math.floor(timestamp / 86400) * 86400;
 };
 
@@ -24,6 +26,24 @@ const DEFAULT_TOTAL_VOLUME_FIELD = "totalVolumeUSD";
 const DEFAULT_DAILY_VOLUME_FACTORY = "uniswapDayData";
 const DEFAULT_DAILY_VOLUME_FIELD = "dailyVolumeUSD";
 
+interface IGetChainVolumeParams {
+  graphUrls: {
+    [chains: string]: string
+  },
+  totalVolume: {
+    factory: string,
+    field: string
+  },
+  dailyVolume?: {
+    factory: string,
+    field: string
+  },
+  customDailyVolume?: string,
+  hasDailyVolume?: boolean
+  hasTotalVolume?: boolean
+  getCustomBlock?: (timestamp: number) => Promise<number>
+}
+
 function getChainVolume({
   graphUrls,
   totalVolume = {
@@ -38,7 +58,7 @@ function getChainVolume({
   hasDailyVolume = true,
   hasTotalVolume = true,
   getCustomBlock = undefined,
-}) {
+}: IGetChainVolumeParams) {
   const totalVolumeQuery = gql`
   ${totalVolume.factory}(
     block: { number: $block }
@@ -56,18 +76,18 @@ function getChainVolume({
     ${dailyVolume.field}
   }
   `;
-
   const graphQuery = gql`
-query get_volume($block: Int, $id: Int) {
-  ${hasTotalVolume ? totalVolumeQuery : ""}
-  ${hasDailyVolume ? dailyVolumeQuery : ""}
-}
-`;
-  return (chain) => {
-    return async (timestamp, chainBlocks) => {
+  query get_volume($block: Int, $id: Int) {
+    ${hasTotalVolume ? totalVolumeQuery : ""}
+    ${hasDailyVolume ? dailyVolumeQuery : ""}
+  }
+  `;
+  return (chain: Chain) => {
+    return async (timestamp: number, chainBlocks: ChainBlocks) => {
       const block =
-        (getCustomBlock && (await getCustomBlock(timestamp))) ||
-        (await getBlock(timestamp, chain, chainBlocks));
+        getCustomBlock ?
+          await getCustomBlock(timestamp) :
+          await getBlock(timestamp, chain, chainBlocks);
       const id = getUniswapDateId();
       const graphRes = await request(graphUrls[chain], graphQuery, {
         block,
@@ -80,14 +100,14 @@ query get_volume($block: Int, $id: Int) {
         totalVolume: graphRes[totalVolume.factory][0][totalVolume.field],
         dailyVolume: hasDailyVolume
           ? (graphRes?.[dailyVolume.factory]?.[dailyVolume.field] || "0") ??
-            undefined
+          undefined
           : undefined,
       };
     };
   };
 }
 
-module.exports = {
+export {
   getUniqStartOfTodayTimestamp,
   getChainVolume,
   DEFAULT_TOTAL_VOLUME_FACTORY,

dexVolumes/soulswap/index.ts

@@ -2,6 +2,7 @@ import { getChainVolume } from "../helper/getUniSubgraphVolume";
 import { getStartTimestamp } from "../helper/getStartTimestamp";
 import { FANTOM } from "../helper/chains";
 import { DexVolumeAdapter } from "../dexVolume.type";
+import { Chain } from "@defillama/sdk/build/general";
 
 const endpoints = {
 // [AVAX]: "https://api.thegraph.com/subgraphs/name/soulswapfinance/avalanche-exchange
@@ -35,7 +36,7 @@ const volume = Object.keys(endpoints).reduce(
   (acc, chain) => ({
     ...acc,
     [chain]: {
-      fetch: graphs(chain),
+      fetch: graphs(chain as Chain),
       start: getStartTimestamp({ ...startTimeQuery, chain }),
     },
   }),