rebase

adapters/types.ts

@@ -70,9 +70,9 @@ export type IStartTimestamp = () => Promise<number>
 export type BaseAdapter = {
   [chain: string]: {
     start: IStartTimestamp | number
-    fetch: Fetch|FetchV2;
+    fetch: Fetch | FetchV2;
     runAtCurrTime?: boolean;
-    customBackfill?: Fetch|FetchV2;
+    customBackfill?: Fetch | FetchV2;
     meta?: {
       methodology?: string | IJSON<string>
       hallmarks?: [number, string][]
@@ -177,6 +177,15 @@ export enum AdapterType {
 
 export type FetchResult = FetchResultVolume & FetchResultFees & FetchResultAggregators & FetchResultOptions & FetchResultIncentives
 
+export const whitelistedDimensionKeys = new Set([
+  'startTimestamp', 'chain', 'timestamp','block',
+
+  'dailyVolume', 'totalVolume', 'dailyShortOpenInterest', 'dailyLongOpenInterest', 'dailyOpenInterest', 'dailyBridgeVolume', 'totalBridgeVolume',
+  'totalFees', 'dailyFees', 'dailyUserFees', 'totalRevenue', 'dailyRevenue', 'dailyProtocolRevenue', 'dailyHoldersRevenue', 'dailySupplySideRevenue', 'totalProtocolRevenue', 'totalSupplySideRevenue', 'totalUserFees', 'dailyBribesRevenue', 'dailyTokenTaxes', 'totalHoldersRevenue',
+  'tokenIncentives',
+  'totalPremiumVolume', 'totalNotionalVolume', 'dailyPremiumVolume', 'dailyNotionalVolume',
+])
+
 // End of specific adaptors type
 
 export interface IJSON<T> {

dexs/unidex/unidex-agg-perp/index.ts → aggregator-derivatives/unidex-agg-perp/index.ts

@@ -1,9 +1,10 @@
 import * as sdk from "@defillama/sdk";
-import { SimpleAdapter, FetchResultVolume } from "../../../adapters/types";
-import { CHAIN } from "../../../helpers/chains";
-import { getTimestampAtStartOfDayUTC } from "../../../utils/date";
+import { FetchResultVolume } from "../../adapters/types";
+import { CHAIN } from "../../helpers/chains";
+import { getTimestampAtStartOfDayUTC } from "../../utils/date";
 import { Chain } from "@defillama/sdk/build/general";
 import request, { gql } from "graphql-request";
+import customBackfill from "../../helpers/customBackfill";
 
 interface IReferralRecord {
   volume: string; // Assuming volume is a string that represents a number
@@ -34,86 +35,25 @@ const fetchReferralVolume = async (timestamp: number): Promise<number> => {
 
   const referralQuery = gql`
     {
-      referrerStats(
-        where: {referrer: "0x8c128f336b479b142429a5f351af225457a987fa", timestamp_gt: "${todaysTimestamp}"}
+      affiliateStats(
+        where: {affiliate: "0x8c128f336b479b142429a5f351af225457a987fa", timestamp_gt: "${todaysTimestamp}"}
       ) {
         volume
       }
     }
   `;
 
-  const referralEndpoint = sdk.graph.modifyEndpoint('Hww5kAfumpAbMm5iGWqEe83vJJCEE98kccmBBcMRy5fU');
+  const referralEndpoint = "https://subgraph.satsuma-prod.com/3b2ced13c8d9/gmx/gmx-arbitrum-referrals/api";
   const referralRes = await request(referralEndpoint, referralQuery);
-
   // If there's no volume data, return 0
-  if (!referralRes.referrerStats || referralRes.referrerStats.length === 0) {
+  if (!referralRes.affiliateStats || referralRes.affiliateStats.length === 0) {
     return 0;
   }
 
-  return Number(referralRes.referrerStats[0].volume) / 10 ** 30;
+  return Number(referralRes.affiliateStats[0].volume) / 10 ** 30;
 };
 
 
-const fetchMuxReferralVolume = async (chain: Chain, timestamp: number): Promise<number> => {
-  const startOfDayTimestamp = getTimestampAtStartOfDayUTC(timestamp);
-  const endOfDayTimestamp = startOfDayTimestamp + 86400; // Add one day's worth of seconds for the end of the day
-
-  const referralQuery = gql`
-    query MyQuery($timestamp_gte: BigInt = "", $timestamp_lte: BigInt = "") {
-      referralRecords(
-        where: {
-          referralCode: "0x556e694465780000000000000000000000000000000000000000000000000000",
-          timestamp_gte: $timestamp_gte,
-          timestamp_lte: $timestamp_lte
-        }
-      ) {
-        volume
-        timestamp
-      }
-    }
-  `;
-
-  const variables = {
-    timestamp_gte: startOfDayTimestamp.toString(),
-    timestamp_lte: endOfDayTimestamp.toString()
-  };
-
-  let referralEndpoint = '';
-
-  switch (chain) {
-    case CHAIN.ARBITRUM:
-      referralEndpoint = sdk.graph.modifyEndpoint('GbsdbMy5X2xHoj8qrRKKTs3LhMgma3CzZ8nZCqo9T97v');
-      break;
-    case CHAIN.OPTIMISM:
-      referralEndpoint = sdk.graph.modifyEndpoint('7CmYmJd9mghA17EP8NXqrLZPqT3vjw4B8PLAbA1K4PdJ');
-      break;
-    case CHAIN.FANTOM:
-      referralEndpoint = sdk.graph.modifyEndpoint('2KNaZgvAu9zjn1oAomgoMgiafQHNBbsS3Eu4UwucPUC6');
-      break;
-    default:
-      return 0; // Return 0 for unsupported chains
-  }
-
-  const referralRes = await request(referralEndpoint, referralQuery, variables);
-
-  // Sum up the volumes
-  let totalVolume = 0;
-
-  if (referralRes.referralRecords && Array.isArray(referralRes.referralRecords)) {
-    referralRes.referralRecords.forEach((record: IReferralRecord) => {
-      const volume = parseFloat(record.volume);
-      if (!isNaN(volume)) {
-        totalVolume += volume / 10 ** 18; // Adjust the unit conversion as needed
-      }
-    });
-  }
-
-  return totalVolume;
-};
-
-
-
-
 const fetch = (chain: Chain) => {
   return async (timestamp: number): Promise<FetchResultVolume> => {
     const todaysTimestamp = getTimestampAtStartOfDayUTC(timestamp);
@@ -145,10 +85,9 @@ const fetch = (chain: Chain) => {
     const chainID = chainIDs[chain];
     let dailyVolumeUSD = chainID !== undefined ? volumeByChain[chainID] || 0 : 0;
 
-    if (chain === CHAIN.ARBITRUM || chain === CHAIN.OPTIMISM || chain === CHAIN.FANTOM) {
+    if (chain === CHAIN.ARBITRUM) {
       const referralVolumeUSD = await fetchReferralVolume(timestamp);
-      const muxReferralVolumeUSD = await fetchMuxReferralVolume(chain, timestamp);
-      dailyVolumeUSD += referralVolumeUSD + muxReferralVolumeUSD;
+      dailyVolumeUSD += referralVolumeUSD;
     }
 
     return {
@@ -183,6 +122,7 @@ const adapteraggderivative: any = {
     [CHAIN.ARBITRUM]: {
       fetch: fetch(CHAIN.ARBITRUM),
       start: 1687422746,
+      customBackfill: customBackfill(CHAIN.ARBITRUM, fetch),
       meta: {
         methodology,
       },
@@ -218,6 +158,4 @@ const adapteraggderivative: any = {
   }
 };
 
-export {
-  adapteraggderivative
-}
+export default adapteraggderivative;

aggregator-derivatives/vooi/index.ts

@@ -1,33 +1,85 @@
 import fetchURL from "../../utils/fetchURL";
-import { FetchResult } from "../../adapters/types";
+import { FetchResult, SimpleAdapter, FetchOptions } from "../../adapters/types";
 import { CHAIN } from "../../helpers/chains";
 
-const URL = "https://defilama-stats.vooi.workers.dev/";
-const endpoint = "";
-const startTimestamp = 1714608000; // 02.05.2024
+const URL = "https://vooi-rebates.fly.dev/";
+const endpoint = "defillama/volumes";
+const startTimestampArbitrum = 1714608000; // 02.05.2024
+const startTimestampBlast = 1719792000; // 01.07.2024
+const startTimestampOpBNB = 1717200000; // 01.06.2024
+const startTimestampBase = 1722470400; // 01.08.2024
 
-
-interface IAPIResponse {
-    dailyVolume: string;
-    totalVolume: string;
-}
-const fetch = async (timestamp: number): Promise<FetchResult> => {
-    const { dailyVolume, totalVolume }: IAPIResponse = (
-        (await fetchURL(`${URL}${endpoint}?ts=${timestamp}`)).data
-    );
+const fetchArbitrum = async (timestamp: number, _t: any, options: FetchOptions): Promise<FetchResult> => {
+    // const timestamp = options.toTimestamp
+    const fetchData = await fetchURL(`${URL}${endpoint}?ts=${options.startOfDay}`) // returns data for the day before
+    let orderlyItem = fetchData.find(((item) => item.protocol == "orderly"))
+    if (!orderlyItem) {
+        orderlyItem = {dailyVolume: 0, totalVolume: 0}
+    }
+    let synfuturesItem = fetchData.filter(((item) => item.protocol == "synfutures"))
+    if (!synfuturesItem) {
+        synfuturesItem = {dailyVolume: 0, totalVolume: 0}
+    }
+    let kiloexItem = fetchData.find(((item) => item.protocol == "kiloex"))
+    if (!kiloexItem) {
+        kiloexItem = {dailyVolume: 0, totalVolume: 0}
+    }
+    let dailyVolume = Number(orderlyItem.dailyVolume) + Number(kiloexItem.dailyVolume)
+    let totalVolume = Number(orderlyItem.totalVolume) + Number(kiloexItem.totalVolume)
+    for (let i in synfuturesItem){
+        dailyVolume = Number(dailyVolume) + Number(synfuturesItem[i].dailyVolume)
+        totalVolume = Number(totalVolume) + Number(synfuturesItem[i].totalVolume)
+    }
     return {
-        timestamp,
         dailyVolume,
         totalVolume,
+        timestamp
+    };
+};
+
+
+const fetchOpBNB = async (timestamp: number): Promise<FetchResult> => {
+    return {
+        dailyVolume: 0,
+        totalVolume: 0,
+        timestamp
+    };
+};
+
+const fetchBlast = async (timestamp: number): Promise<FetchResult> => {
+    return {
+        dailyVolume: 0,
+        totalVolume: 0,
+        timestamp
     };
 };
 
-export default {
+const fetchBase = async (timestamp: number): Promise<FetchResult> => {
+    return {
+        dailyVolume: 0,
+        totalVolume: 0,
+        timestamp
+    };
+};
+
+const adapter: SimpleAdapter = {
     adapter: {
         [CHAIN.ARBITRUM]: {
-            fetch: fetch,
-            start: startTimestamp
+            fetch: fetchArbitrum,
+            start: startTimestampArbitrum
+        },
+        [CHAIN.OP_BNB]: {
+            fetch: fetchOpBNB,
+            start: startTimestampOpBNB
+        },
+        [CHAIN.BLAST]: {
+            fetch: fetchBlast,
+            start: startTimestampBlast
+        },
+        [CHAIN.BASE]: {
+            fetch: fetchBase,
+            start: startTimestampBase
         },
     },
-    // version: 2 // data accepts only one input to timestamp
 }
+export default adapter

aggregators/akka/index.ts

@@ -23,10 +23,11 @@ const fetch = async (timestamp: number): Promise<FetchResult> => {
 }
 
 const adapter: SimpleAdapter = {
-    version: 2,
+    version: 1,
     adapter: {
         [CHAIN.CORE]: {
             fetch,
+            runAtCurrTime: true,
             start: startTimestamp,
         },
     },

aggregators/chainspot/index.ts

@@ -0,0 +1,101 @@
+import { httpGet } from "../../utils/fetchURL";
+import { getUniqStartOfTodayTimestamp } from "../../helpers/getUniSubgraphVolume";
+import { CHAIN } from "../../helpers/chains";
+import { FetchOptions } from "../../adapters/types";
+
+const chains = [
+    CHAIN.ETHEREUM,
+    CHAIN.POLYGON,
+    CHAIN.BSC,
+    CHAIN.AVAX,
+    CHAIN.OPTIMISM,
+    CHAIN.FANTOM,
+    CHAIN.ARBITRUM,
+    CHAIN.AURORA,
+    CHAIN.CELO,
+    CHAIN.BOBA,
+    CHAIN.XDAI,
+    CHAIN.TELOS,
+    CHAIN.BASE,
+    CHAIN.LINEA,
+    CHAIN.MANTLE,
+    CHAIN.MOONBEAM,
+    CHAIN.CRONOS,
+    CHAIN.BLAST,
+    CHAIN.EVMOS,
+    CHAIN.FUSE,
+    CHAIN.HARMONY,
+    CHAIN.KAVA,
+    CHAIN.MOONRIVER,
+    CHAIN.OKEXCHAIN,
+    CHAIN.SCROLL,
+    CHAIN.TRON,
+    CHAIN.TON,
+    CHAIN.WAN,
+    CHAIN.ZKLINK,
+    CHAIN.ZKSYNC,
+];
+
+const chainToId: Record<string, number> = {
+    [CHAIN.ETHEREUM]: 1,
+    [CHAIN.POLYGON]: 137,
+    [CHAIN.BSC]: 56,
+    [CHAIN.AVAX]: 43114,
+    [CHAIN.OPTIMISM]: 10,
+    [CHAIN.FANTOM]: 250,
+    [CHAIN.ARBITRUM]: 42161,
+    [CHAIN.AURORA]: 1313161554,
+    [CHAIN.CELO]: 42220,
+    [CHAIN.BOBA]: 288,
+    [CHAIN.XDAI]: 100,
+    [CHAIN.TELOS]: 40,
+    [CHAIN.BASE]: 8453,
+    [CHAIN.LINEA]: 59144,
+    [CHAIN.MANTLE]: 5000,
+    [CHAIN.MOONBEAM]: 1284,
+    [CHAIN.CRONOS]: 25,
+    [CHAIN.BLAST]: 81457,
+    [CHAIN.EVMOS]: 9001,
+    [CHAIN.FUSE]: 122,
+    [CHAIN.HARMONY]: 1666600000,
+    [CHAIN.KAVA]: 2222,
+    [CHAIN.MOONRIVER]: 1285,
+    [CHAIN.OKEXCHAIN]: 66,
+    [CHAIN.SCROLL]: 534352,
+    [CHAIN.TRON]: 728126428,
+    [CHAIN.TON]: -239,
+    [CHAIN.WAN]: 888,
+    [CHAIN.ZKLINK]: 810180,
+    [CHAIN.ZKSYNC]: 324,
+};
+
+const fetch = async (_at: number, _t: any, options: FetchOptions) => {
+    const unixTimestamp = getUniqStartOfTodayTimestamp(
+        new Date(options.startOfDay * 1000)
+    );
+    const url = `https://app.chainspot.io/api/2.0/statistic/daily-volume?chainId=${chainToId[options.chain]}&timestamp=${unixTimestamp * 1e3}`;
+    const volume = (
+        await httpGet(url)
+    )?.volume;
+
+    return {
+        dailyVolume: volume  || 0,
+        timestamp: unixTimestamp,
+    };
+};
+
+const adapter: any = {
+    adapter: {
+        ...chains.reduce((acc, chain) => {
+            return {
+                ...acc,
+                [chain]: {
+                    fetch: fetch,
+                    start: 1704067200,
+                },
+            };
+        }, {}),
+    },
+};
+
+export default adapter;