Refactor/dev 234 create treasury endpoint

apps/api-gateway/schema.graphql

@@ -38,8 +38,18 @@ type Query {
   tokenPrices(where: tokenPriceFilter, orderBy: String, orderDirection: String, before: String, after: String, limit: Int): tokenPricePage!
   _meta: Meta
 
-  """Get total assets"""
-  totalAssets(days: queryInput_totalAssets_days = _7d): [query_totalAssets_items]
+  """
+  Get historical Liquid Treasury (treasury without DAO tokens) from external providers (DefiLlama/Dune)
+  """
+  getLiquidTreasury(days: queryInput_getLiquidTreasury_days = _365d, order: queryInput_getLiquidTreasury_order = asc): getLiquidTreasury_200_response
+
+  """
+  Get historical DAO Token Treasury value (governance token quantity × token price)
+  """
+  getDaoTokenTreasury(days: queryInput_getDaoTokenTreasury_days = _365d, order: queryInput_getDaoTokenTreasury_order = asc): getDaoTokenTreasury_200_response
+
+  """Get historical Total Treasury (liquid treasury + DAO token treasury)"""
+  getTotalTreasury(days: queryInput_getTotalTreasury_days = _365d, order: queryInput_getTotalTreasury_order = asc): getTotalTreasury_200_response
 
   """Get historical market data for a specific token"""
   historicalTokenData(skip: NonNegativeInt, limit: Float = 365): [query_historicalTokenData_items]
@@ -1330,19 +1340,90 @@ input tokenPriceFilter {
   timestamp_lte: BigInt
 }
 
-type query_totalAssets_items {
-  totalAssets: String!
-  date: String!
+type getLiquidTreasury_200_response {
+  items: [query_getLiquidTreasury_items_items]!
+
+  """Total number of items"""
+  totalCount: Float!
+}
+
+type query_getLiquidTreasury_items_items {
+  """Treasury value in USD"""
+  value: Float!
+
+  """Unix timestamp in milliseconds"""
+  date: Float!
+}
+
+enum queryInput_getLiquidTreasury_days {
+  _7d
+  _30d
+  _90d
+  _180d
+  _365d
+}
+
+enum queryInput_getLiquidTreasury_order {
+  asc
+  desc
+}
+
+type getDaoTokenTreasury_200_response {
+  items: [query_getDaoTokenTreasury_items_items]!
+
+  """Total number of items"""
+  totalCount: Float!
+}
+
+type query_getDaoTokenTreasury_items_items {
+  """Treasury value in USD"""
+  value: Float!
+
+  """Unix timestamp in milliseconds"""
+  date: Float!
+}
+
+enum queryInput_getDaoTokenTreasury_days {
+  _7d
+  _30d
+  _90d
+  _180d
+  _365d
+}
+
+enum queryInput_getDaoTokenTreasury_order {
+  asc
+  desc
 }
 
-enum queryInput_totalAssets_days {
+type getTotalTreasury_200_response {
+  items: [query_getTotalTreasury_items_items]!
+
+  """Total number of items"""
+  totalCount: Float!
+}
+
+type query_getTotalTreasury_items_items {
+  """Treasury value in USD"""
+  value: Float!
+
+  """Unix timestamp in milliseconds"""
+  date: Float!
+}
+
+enum queryInput_getTotalTreasury_days {
   _7d
   _30d
   _90d
   _180d
   _365d
 }
 
+enum queryInput_getTotalTreasury_order {
+  asc
+  desc
+}
+
 type query_historicalTokenData_items {
   price: String!
   timestamp: Float!

apps/dashboard/features/attack-profitability/components/AttackCostBarChart.tsx

@@ -29,7 +29,7 @@ import { mockedAttackCostBarData } from "@/shared/constants/mocked-data/mocked-a
 import {
   useDaoTokenHistoricalData,
   useTopTokenHolderNonDao,
-  useTreasuryAssetNonDaoToken,
+  useTreasury,
   useVetoCouncilVotingPower,
 } from "@/features/attack-profitability/hooks";
 import daoConfigByDaoId from "@/shared/dao-config";
@@ -71,10 +71,8 @@ export const AttackCostBarChart = ({
   const selectedDaoId = daoId.toUpperCase() as DaoIdEnum;
   const timeInterval = TimeInterval.NINETY_DAYS;
 
-  const liquidTreasury = useTreasuryAssetNonDaoToken(
-    selectedDaoId,
-    timeInterval,
-  );
+  const { data: liquidTreasuryData, loading: liquidTreasuryLoading } =
+    useTreasury(selectedDaoId, "liquid", TimeInterval.SEVEN_DAYS);
   const delegatedSupply = useDelegatedSupply(selectedDaoId, timeInterval);
   const activeSupply = useActiveSupply(selectedDaoId, timeInterval);
   const averageTurnout = useAverageTurnout(selectedDaoId, timeInterval);
@@ -104,7 +102,7 @@ export const AttackCostBarChart = ({
   const { isMobile } = useScreenSize();
 
   const isLoading =
-    liquidTreasury.loading ||
+    liquidTreasuryLoading ||
     delegatedSupply.isLoading ||
     activeSupply.isLoading ||
     averageTurnout.isLoading ||
@@ -152,10 +150,10 @@ export const AttackCostBarChart = ({
               id: "liquidTreasury",
               name: "Liquid Treasury",
               type: BarChartEnum.REGULAR,
-              value: Number(liquidTreasury.data?.[0]?.totalAssets || 0),
+              value: Number(liquidTreasuryData?.[0]?.value || 0),
               customColor: "#EC762EFF",
               displayValue:
-                Number(liquidTreasury.data?.[0]?.totalAssets || 0) > 10000
+                Number(liquidTreasuryData?.[0]?.value || 0) > 10000
                   ? undefined
                   : "<$10,000",
             },
@@ -226,7 +224,7 @@ export const AttackCostBarChart = ({
     mocked,
     daoTokenPriceHistoricalData,
     valueMode,
-    liquidTreasury.data,
+    liquidTreasuryData,
     delegatedSupply.data?.currentDelegatedSupply,
     activeSupply.data?.activeSupply,
     averageTurnout.data?.currentAverageTurnout,

apps/dashboard/features/attack-profitability/components/MultilineChartAttackProfitability.tsx

@@ -27,18 +27,14 @@ import { ResearchPendingChartBlur } from "@/shared/components/charts/ResearchPen
 import { AttackProfitabilityCustomTooltip } from "@/features/attack-profitability/components";
 import {
   useDaoTokenHistoricalData,
-  useTreasuryAssetNonDaoToken,
+  useTreasury,
 } from "@/features/attack-profitability/hooks";
 import {
   cn,
   formatNumberUserReadable,
   timestampToReadableDate,
 } from "@/shared/utils";
-import {
-  normalizeDataset,
-  normalizeDatasetTreasuryNonDaoToken,
-  normalizeDatasetAllTreasury,
-} from "@/features/attack-profitability/utils";
+import { normalizeDataset } from "@/features/attack-profitability/utils";
 import daoConfigByDaoId from "@/shared/dao-config";
 import { AnticaptureWatermark } from "@/shared/components/icons/AnticaptureWatermark";
 import { Data } from "react-csv/lib/core";
@@ -62,14 +58,20 @@ export const MultilineChartAttackProfitability = ({
   const { data: daoData } = useDaoData(daoEnum);
   const daoConfig = daoConfigByDaoId[daoEnum];
 
-  const { data: treasuryAssetNonDAOToken = [] } = useTreasuryAssetNonDaoToken(
+  const { data: liquidTreasuryData } = useTreasury(
     daoEnum,
-    days,
+    "liquid",
+    days as TimeInterval,
+  );
+  const { data: totalTreasuryData } = useTreasury(
+    daoEnum,
+    "total",
+    days as TimeInterval,
   );
 
   const { data: daoTokenPriceHistoricalData } = useDaoTokenHistoricalData({
     daoId: daoEnum,
-    limit: Number(days.split("d")[0]) - 7,
+    limit: Number(days.split("d")[0]),
   });
 
   const { data: timeSeriesData } = useTimeSeriesData(
@@ -108,9 +110,7 @@ export const MultilineChartAttackProfitability = ({
 
   const chartData = useMemo(() => {
     let delegatedSupplyChart: DaoMetricsDayBucket[] = [];
-    let treasurySupplyChart: DaoMetricsDayBucket[] = [];
     if (timeSeriesData) {
-      treasurySupplyChart = timeSeriesData[MetricTypesEnum.TREASURY];
       delegatedSupplyChart = timeSeriesData[MetricTypesEnum.DELEGATED_SUPPLY];
     }
 
@@ -119,17 +119,14 @@ export const MultilineChartAttackProfitability = ({
       datasets = mockedAttackProfitabilityDatasets;
     } else {
       datasets = {
-        treasuryNonDAO: normalizeDatasetTreasuryNonDaoToken(
-          treasuryAssetNonDAOToken,
-          "treasuryNonDAO",
-        ).reverse(),
-        all: normalizeDatasetAllTreasury(
-          daoTokenPriceHistoricalData,
-          "all",
-          treasuryAssetNonDAOToken,
-          treasurySupplyChart,
-          daoConfig.decimals,
-        ),
+        treasuryNonDAO: liquidTreasuryData.map((item) => ({
+          date: item.date,
+          treasuryNonDAO: item.value,
+        })),
+        all: totalTreasuryData.map((item) => ({
+          date: item.date,
+          all: item.value,
+        })),
         quorum: daoConfig?.attackProfitability?.dynamicQuorum?.percentage
           ? normalizeDataset(
               daoTokenPriceHistoricalData,
@@ -195,7 +192,8 @@ export const MultilineChartAttackProfitability = ({
     mocked,
     quorumValue,
     daoTokenPriceHistoricalData,
-    treasuryAssetNonDAOToken,
+    liquidTreasuryData,
+    totalTreasuryData,
     timeSeriesData,
     daoConfig?.attackProfitability?.dynamicQuorum?.percentage,
     daoConfig.decimals,

apps/dashboard/features/attack-profitability/hooks/index.ts

@@ -1,4 +1,4 @@
 export * from "@/features/attack-profitability/hooks/useVetoCouncilVotingPower";
 export * from "@/features/attack-profitability/hooks/useDaoTokenHistoricalData";
 export * from "@/features/attack-profitability/hooks/useTopTokenHolderNonDao";
-export * from "@/features/attack-profitability/hooks/useTreasuryAssetNonDaoToken";
+export * from "@/features/attack-profitability/hooks/useTreasury";

apps/dashboard/features/attack-profitability/hooks/useTreasury.ts

@@ -0,0 +1,81 @@
+import useSWR from "swr";
+import axios from "axios";
+import { DaoIdEnum } from "@/shared/types/daos";
+import { TimeInterval } from "@/shared/types/enums/TimeInterval";
+import { BACKEND_ENDPOINT } from "@/shared/utils/server-utils";
+
+export type TreasuryType = "liquid" | "dao-token" | "total";
+
+export interface TreasuryDataPoint {
+  value: number;
+  date: number;
+}
+
+export interface TreasuryResponse {
+  items: TreasuryDataPoint[];
+  totalCount: number;
+}
+
+const QUERY_NAME_MAP: Record<TreasuryType, string> = {
+  liquid: "getLiquidTreasury",
+  "dao-token": "getDaoTokenTreasury",
+  total: "getTotalTreasury",
+};
+
+const fetchTreasury = async ({
+  daoId,
+  type = "total",
+  days = TimeInterval.ONE_YEAR,
+  order = "asc",
+}: {
+  daoId: DaoIdEnum;
+  type?: TreasuryType;
+  days?: TimeInterval;
+  order?: "asc" | "desc";
+}): Promise<TreasuryResponse> => {
+  const queryName = QUERY_NAME_MAP[type];
+  const daysParam = `_${days}`;
+
+  const query = `query GetTreasury {
+    ${queryName}(days: ${daysParam}, order: ${order}) {
+      items {
+        date
+        value
+      }
+      totalCount
+    }
+  }`;
+
+  const response: {
+    data: { data: { [key: string]: TreasuryResponse } };
+  } = await axios.post(
+    `${BACKEND_ENDPOINT}`,
+    { query },
+    { headers: { "anticapture-dao-id": daoId } },
+  );
+
+  return response.data.data[queryName];
+};
+
+export const useTreasury = (
+  daoId: DaoIdEnum,
+  type: TreasuryType = "total",
+  days: TimeInterval = TimeInterval.ONE_YEAR,
+  order: "asc" | "desc" = "asc",
+) => {
+  const { data, error, isValidating } = useSWR<TreasuryResponse>(
+    ["treasury", daoId, type, days, order],
+    () => fetchTreasury({ daoId, type, days, order }),
+    {
+      revalidateOnFocus: false,
+      shouldRetryOnError: false,
+    },
+  );
+
+  return {
+    data: data?.items ?? [],
+    totalCount: data?.totalCount ?? 0,
+    loading: isValidating,
+    error,
+  };
+};