fix/volume-issue-#79

src/hooks/pools.ts

@@ -1,88 +1,88 @@
-import { useQuery } from "@tanstack/react-query";
-import {
-  fetchPool,
-  fetchPoolFeesChart,
-  fetchPoolTVLChart,
-  fetchPoolVolumeChart,
-  fetchPools,
-  fetchPoolsByTokenAddress,
-} from "../services/pools";
-import useQueryNetwork from "./use-query-network";
+  import { useQuery } from "@tanstack/react-query";
+  import {
+    fetchPool,
+    fetchPoolFeesChart,
+    fetchPoolTVLChart,
+    fetchPoolVolumeChart,
+    fetchPools,
+    fetchPoolsByTokenAddress,
+  } from "../services/pools";
+  import useQueryNetwork from "./use-query-network";
 
-const key = "pools";
+  const key = "pools";
 
-export const useQueryPools = () => {
-  const { network, isValidQuery } = useQueryNetwork();
+  export const useQueryPools = () => {
+    const { network, isValidQuery } = useQueryNetwork();
 
-  return useQuery({
-    queryKey: [key, network],
-    queryFn: () => fetchPools({ network: network! }),
-    enabled: isValidQuery,
-  });
-};
+    return useQuery({
+      queryKey: [key, network],
+      queryFn: () => fetchPools({ network: network! }),
+      enabled: isValidQuery,
+    });
+  };
 
-export const useQueryPool = ({ poolAddress }: { poolAddress: string }) => {
-  const { network, isValidQuery } = useQueryNetwork();
+  export const useQueryPool = ({ poolAddress }: { poolAddress: string }) => {
+    const { network, isValidQuery } = useQueryNetwork();
 
-  return useQuery({
-    queryKey: [key, network, poolAddress],
-    queryFn: () => fetchPool({ poolAddress, network: network! }),
-    enabled: !!poolAddress && isValidQuery,
-  });
-};
+    return useQuery({
+      queryKey: [key, network, poolAddress],
+      queryFn: () => fetchPool({ poolAddress, network: network! }),
+      enabled: !!poolAddress && isValidQuery,
+    });
+  };
 
-export const useQueryPoolTVLChart = ({
-  poolAddress,
-}: {
-  poolAddress: string;
-}) => {
-  const { network, isValidQuery } = useQueryNetwork();
+  export const useQueryPoolTVLChart = ({
+    poolAddress,
+  }: {
+    poolAddress: string;
+  }) => {
+    const { network, isValidQuery } = useQueryNetwork();
 
-  return useQuery({
-    queryKey: [key, network, poolAddress, "tvl-chart"],
-    queryFn: () => fetchPoolTVLChart({ poolAddress }),
-    enabled: !!poolAddress && isValidQuery,
-  });
-};
+    return useQuery({
+      queryKey: [key, network, poolAddress, "tvl-chart"],
+      queryFn: () => fetchPoolTVLChart({ poolAddress }),
+      enabled: !!poolAddress && isValidQuery,
+    });
+  };
 
-export const useQueryPoolFeesChart = ({
-  poolAddress,
-}: {
-  poolAddress: string;
-}) => {
-  const { network, isValidQuery } = useQueryNetwork();
+  export const useQueryPoolFeesChart = ({
+    poolAddress,
+  }: {
+    poolAddress: string;
+  }) => {
+    const { network, isValidQuery } = useQueryNetwork();
 
-  return useQuery({
-    queryKey: [key, network, poolAddress, "fees-chart"],
-    queryFn: () => fetchPoolFeesChart({ poolAddress }),
-    enabled: !!poolAddress && isValidQuery,
-  });
-};
+    return useQuery({
+      queryKey: [key, network, poolAddress, "fees-chart"],
+      queryFn: () => fetchPoolFeesChart({ poolAddress }),
+      enabled: !!poolAddress && isValidQuery,
+    });
+  };
 
-export const useQueryPoolVolumeChart = ({
-  poolAddress,
-}: {
-  poolAddress: string;
-}) => {
-  const { network, isValidQuery } = useQueryNetwork();
+  export const useQueryPoolVolumeChart = ({
+    poolAddress,
+  }: {
+    poolAddress: string;
+  }) => {
+    const { network, isValidQuery } = useQueryNetwork();
 
-  return useQuery({
-    queryKey: [key, network, poolAddress, "volume-chart"],
-    queryFn: () => fetchPoolVolumeChart({ poolAddress }),
-    enabled: !!poolAddress && isValidQuery,
-  });
-};
+    return useQuery({
+      queryKey: [key, network, poolAddress, "volume-chart"],
+      queryFn: () => fetchPoolVolumeChart({ poolAddress, network: network! }),
+      enabled: !!poolAddress && isValidQuery,
+    });
+  };
 
-export const useQueryPoolsByTokenAddress = ({
-  tokenAddress,
-}: {
-  tokenAddress: string;
-}) => {
-  const { network, isValidQuery } = useQueryNetwork();
+  export const useQueryPoolsByTokenAddress = ({
+    tokenAddress,
+  }: {
+    tokenAddress: string;
+  }) => {
+    const { network, isValidQuery } = useQueryNetwork();
 
-  return useQuery({
-    queryKey: [key, network, tokenAddress],
-    queryFn: () => fetchPoolsByTokenAddress({ tokenAddress }),
-    enabled: !!tokenAddress && isValidQuery,
-  });
-};
+    return useQuery({
+      queryKey: [key, network, tokenAddress],
+      queryFn: () => fetchPoolsByTokenAddress({ tokenAddress }),
+      enabled: !!tokenAddress && isValidQuery,
+    });
+  };

src/services/events.ts

@@ -10,6 +10,12 @@ interface FetchAllEventsProps extends ApiNetwork {
   address?: string;
 }
 
+export enum EventType {
+  SWAP = 'swap',
+  ADD_LIQUIDITY = 'add_liquidity',
+  REMOVE_LIQUIDITY = 'remove_liquidity'
+}
+
 export const fetchAllEvents = async ({
   type,
   address,
@@ -18,9 +24,14 @@ export const fetchAllEvents = async ({
   const { data } = await axiosInstance.get<RouterEventsAPIResponse>(
     `/api/events`,
     {
-      params: { type, address, network },
+      params: { 
+        type, 
+        address, 
+        network,
+        eventType: EventType.SWAP
+      },
     }
   );
 
   return data;
-};
+};

src/services/pools.ts

@@ -1,7 +1,10 @@
-import { ApiNetwork } from "types/network";
+import { ApiNetwork, Network } from "types/network";
 import { Pool } from "../types/pools";
 import { fillDatesAndSort } from "../utils/complete-chart";
 import axiosInstance from "./axios";
+import { EventType, fetchAllEvents } from './events';
+import { RouterEventAPI } from "types/router-events";
+
 
 export const fetchPools = async ({ network }: ApiNetwork) => {
   const { data } = await axiosInstance.get<Pool[]>("/api/pairs", {
@@ -14,6 +17,14 @@ export const fetchPools = async ({ network }: ApiNetwork) => {
 interface FetchPoolProps extends ApiNetwork {
   poolAddress: string;
 }
+export const fetchPoolsByTokenAddress = async ({
+  tokenAddress,
+}: {
+  tokenAddress: string;
+}) => {
+  const { data } = await axiosInstance.get(`/info/pools/${tokenAddress}`);
+  return data;
+};
 
 export const fetchPool = async ({ poolAddress, network }: FetchPoolProps) => {
   const { data } = await axiosInstance.get<Pool>(
@@ -53,23 +64,75 @@ export const fetchPoolFeesChart = async ({
 
 export const fetchPoolVolumeChart = async ({
   poolAddress,
+  network,
 }: {
   poolAddress: string;
+  network: Network;
 }) => {
-  const { data } = await axiosInstance.get<{ volume: number; date: string }[]>(
-    `/info/pool/volume-chart/${poolAddress}?protocols=soroswap`
-  );
+  try {
+
+    const events = await fetchAllEvents({
+      address: poolAddress,
+      type: EventType.SWAP,
+      network,
+    });
 
-  const filledData = fillDatesAndSort(data, "volume");
+
+    const volumeByDate = events.reduce((acc: { [key: string]: number }, event: RouterEventAPI) => {
+
+      const timestamp = event.timestamp ? new Date(event.timestamp) : new Date();
+      const date = timestamp.toISOString().split('T')[0];
+
+
+      const eventVolume = calculateEventVolume(event);
+
+
+      acc[date] = (acc[date] || 0) + eventVolume;
+
+      return acc;
+    }, {});
 
-  return filledData;
-};
+
+    const volumeData = Object.entries(volumeByDate).map(([date, volume]) => ({
+      date,
+      volume
+    }));
 
-export const fetchPoolsByTokenAddress = async ({
-  tokenAddress,
-}: {
-  tokenAddress: string;
-}) => {
-  const { data } = await axiosInstance.get(`/info/pools/${tokenAddress}`);
-  return data;
+
+    const filledData = fillDatesAndSort(volumeData, "volume");
+
+    return filledData;
+  } catch (error) {
+    console.error('Error fetching pool volume chart:', error);
+    return [];
+  }
 };
+
+
+function calculateEventVolume(event: any): number {
+
+  if (!event || event.type !== EventType.SWAP) {
+    return 0;
+  }
+
+
+  if (event.amount0 !== undefined && event.amount1 !== undefined) {
+    return Math.max(
+      Number(event.amount0) || 0,
+      Number(event.amount1) || 0
+    );
+  }
+
+  if (event.amountIn !== undefined && event.amountOut !== undefined) {
+    return Math.max(
+      Number(event.amountIn) || 0,
+      Number(event.amountOut) || 0
+    );
+  }
+
+  if (event.volume !== undefined) {
+    return Number(event.volume);
+  }
+
+  return 0;
+}