feat: morpho api backup

app/market/[chainId]/[marketid]/content.tsx

@@ -131,7 +131,9 @@ function MarketContent() {
 
   // Non-async wrapper for components that expect void returns
   const handleRefreshAllSync = useCallback(() => {
-    void handleRefreshAll();
+    void handleRefreshAll().catch((error) => {
+      console.error('Failed to refresh data:', error);
+    });
   }, [handleRefreshAll]);
 
   // Unified handler for timeframe changes
@@ -200,9 +202,12 @@ function MarketContent() {
             <Button
               size="md"
               className="mb-4"
-              onClick={() =>
-                window.open(getMarketURL(market.uniqueKey, market.morphoBlue.chain.id), '_blank')
-              }
+              onClick={() => {
+                void window.open(
+                  getMarketURL(market.uniqueKey, market.morphoBlue.chain.id),
+                  '_blank',
+                );
+              }}
             >
               View on Morpho
               <Image src={MORPHO_LOGO} alt="Morpho Logo" width={20} height={20} className="ml-2" />

src/config/dataSources.ts

@@ -1,30 +1,14 @@
 import { SupportedNetworks } from '@/utils/networks';
 
 /**
- * Determines the primary data source for market details based on the network.
+ * Check if a network supports Morpho API as a data source
  */
-export const getMarketDataSource = (network: SupportedNetworks): 'morpho' | 'subgraph' => {
+export const supportsMorphoApi = (network: SupportedNetworks): boolean => {
   switch (network) {
     case SupportedNetworks.Mainnet:
-      return 'morpho';
     case SupportedNetworks.Base:
-      return 'morpho';
+      return true;
     default:
-      return 'subgraph'; // Default to Subgraph
-  }
-};
-
-/**
- * Determines the data source for historical market data.
- * Assumes only Morpho API provides this, unless explicitly excluded.
- */
-export const getHistoricalDataSource = (network: SupportedNetworks): 'morpho' | 'subgraph' => {
-  switch (network) {
-    case SupportedNetworks.Mainnet:
-      return 'morpho';
-    case SupportedNetworks.Base:
-      return 'morpho';
-    default:
-      return 'subgraph';
+      return false;
   }
 };

src/contexts/MarketsContext.tsx

@@ -9,7 +9,7 @@ import {
   useState,
   useMemo,
 } from 'react';
-import { getMarketDataSource } from '@/config/dataSources';
+import { supportsMorphoApi } from '@/config/dataSources';
 import { fetchMorphoMarkets } from '@/data-sources/morpho-api/market';
 import { fetchSubgraphMarkets } from '@/data-sources/subgraph/market';
 import useLiquidations from '@/hooks/useLiquidations';
@@ -78,7 +78,7 @@ export function MarketsProvider({ children }: MarketsProviderProps) {
         SupportedNetworks.Mainnet,
         SupportedNetworks.Base,
         SupportedNetworks.Polygon,
-        SupportedNetworks.Unichain
+        SupportedNetworks.Unichain,
       ];
       let combinedMarkets: Market[] = [];
       let fetchErrors: unknown[] = [];
@@ -88,17 +88,34 @@ export function MarketsProvider({ children }: MarketsProviderProps) {
         await Promise.all(
           networksToFetch.map(async (network) => {
             try {
-              const dataSource = getMarketDataSource(network);
               let networkMarkets: Market[] = [];
 
-              console.log(`Fetching markets for ${network} via ${dataSource}`);
+              // Try Morpho API first if supported
+              if (supportsMorphoApi(network)) {
+                try {
+                  console.log(`Attempting to fetch markets via Morpho API for ${network}`);
+                  networkMarkets = await fetchMorphoMarkets(network);
+                } catch (morphoError) {
+                  console.error(
+                    `Failed to fetch markets via Morpho API for ${network}:`,
+                    morphoError,
+                  );
+                  // Continue to Subgraph fallback
+                }
+              }
 
-              if (dataSource === 'morpho') {
-                networkMarkets = await fetchMorphoMarkets(network);
-              } else if (dataSource === 'subgraph') {
-                networkMarkets = await fetchSubgraphMarkets(network);
-              } else {
-                console.warn(`No valid data source found for network ${network}`);
+              // If Morpho API failed or not supported, try Subgraph
+              if (networkMarkets.length === 0) {
+                try {
+                  console.log(`Attempting to fetch markets via Subgraph for ${network}`);
+                  networkMarkets = await fetchSubgraphMarkets(network);
+                } catch (subgraphError) {
+                  console.error(
+                    `Failed to fetch markets via Subgraph for ${network}:`,
+                    subgraphError,
+                  );
+                  throw subgraphError; // Throw to be caught by outer catch
+                }
               }
 
               combinedMarkets.push(...networkMarkets);
@@ -114,7 +131,7 @@ export function MarketsProvider({ children }: MarketsProviderProps) {
         const filtered = combinedMarkets
           .filter((market) => market.collateralAsset != undefined)
           .filter((market) => isSupportedChain(market.morphoBlue.chain.id)) // Keep this filter
-          .filter((market) => !blacklistedMarkets.includes(market.uniqueKey)); // Filter out blacklisted markets
+          .filter((market) => !blacklistedMarkets.includes(market.uniqueKey));
 
         const processedMarkets = filtered.map((market) => {
           const warningsWithDetail = getMarketWarningsWithDetail(market, true); // Recalculate warnings if needed, though fetchers might do this
@@ -166,14 +183,24 @@ export function MarketsProvider({ children }: MarketsProviderProps) {
 
   useEffect(() => {
     if (!liquidationsLoading && whitelistedMarkets.length === 0) {
-      fetchMarkets().catch(console.error);
+      void fetchMarkets().catch(console.error);
     }
+
+    // Set up refresh interval
+    const refreshInterval = setInterval(
+      () => {
+        void fetchMarkets(true).catch(console.error);
+      },
+      5 * 60 * 1000,
+    ); // Refresh every 5 minutes
+
+    return () => clearInterval(refreshInterval);
   }, [liquidationsLoading, fetchMarkets, whitelistedMarkets.length]);
 
   const refetch = useCallback(
     async (onSuccess?: () => void) => {
       try {
-        refetchLiquidations();
+        await refetchLiquidations();
         await fetchMarkets(true);
         onSuccess?.();
       } catch (err) {
@@ -189,7 +216,7 @@ export function MarketsProvider({ children }: MarketsProviderProps) {
     setAllMarkets([]);
     setError(null);
     try {
-      refetchLiquidations();
+      await refetchLiquidations();
       await fetchMarkets();
     } catch (_error) {
       console.error('Failed to refresh markets:', _error);

src/data-sources/morpho-api/transactions.ts

@@ -21,9 +21,10 @@ export const fetchMorphoTransactions = async (
     chainId_in: filters.chainIds ?? [SupportedNetworks.Base, SupportedNetworks.Mainnet],
   };
 
-  if (filters.marketUniqueKeys && filters.marketUniqueKeys.length > 0) {
-    whereClause.marketUniqueKey_in = filters.marketUniqueKeys;
-  }
+  // disable cuz it's too long
+  // if (filters.marketUniqueKeys && filters.marketUniqueKeys.length > 0) {
+  //   whereClause.marketUniqueKey_in = filters.marketUniqueKeys;
+  // }
   if (filters.timestampGte !== undefined && filters.timestampGte !== null) {
     whereClause.timestamp_gte = filters.timestampGte;
   }

src/hooks/useLiquidations.ts

@@ -1,5 +1,5 @@
 import { useState, useEffect, useCallback } from 'react';
-import { getMarketDataSource } from '@/config/dataSources';
+import { supportsMorphoApi } from '@/config/dataSources';
 import { fetchMorphoApiLiquidatedMarketKeys } from '@/data-sources/morpho-api/liquidations';
 import { fetchSubgraphLiquidatedMarketKeys } from '@/data-sources/subgraph/liquidations';
 import { SupportedNetworks } from '@/utils/networks';
@@ -31,57 +31,73 @@ const useLiquidations = () => {
       await Promise.all(
         networksToCheck.map(async (network) => {
           try {
-            const dataSource = getMarketDataSource(network);
             let networkLiquidatedKeys: Set<string>;
 
-            console.log(`Fetching liquidated markets for ${network} via ${dataSource}`);
-
-            if (dataSource === 'morpho') {
-              networkLiquidatedKeys = await fetchMorphoApiLiquidatedMarketKeys(network);
-            } else if (dataSource === 'subgraph') {
-              networkLiquidatedKeys = await fetchSubgraphLiquidatedMarketKeys(network);
+            // Try Morpho API first if supported
+            if (supportsMorphoApi(network)) {
+              try {
+                console.log(`Attempting to fetch liquidated markets via Morpho API for ${network}`);
+                networkLiquidatedKeys = await fetchMorphoApiLiquidatedMarketKeys(network);
+              } catch (morphoError) {
+                console.error(`Failed to fetch liquidated markets via Morpho API:`, morphoError);
+                // Continue to Subgraph fallback
+                networkLiquidatedKeys = new Set();
+              }
             } else {
-              console.warn(`No valid data source found for network ${network} for liquidations.`);
-              networkLiquidatedKeys = new Set<string>(); // Assume none if no source
+              networkLiquidatedKeys = new Set();
+            }
+
+            // If Morpho API failed or not supported, try Subgraph
+            if (networkLiquidatedKeys.size === 0) {
+              try {
+                console.log(`Attempting to fetch liquidated markets via Subgraph for ${network}`);
+                networkLiquidatedKeys = await fetchSubgraphLiquidatedMarketKeys(network);
+              } catch (subgraphError) {
+                console.error(`Failed to fetch liquidated markets via Subgraph:`, subgraphError);
+                throw subgraphError; // Throw to be caught by outer catch
+              }
             }
 
-            // Add keys from this network to the combined set
+            // Add the keys to the combined set
             networkLiquidatedKeys.forEach((key) => combinedLiquidatedKeys.add(key));
           } catch (networkError) {
             console.error(
-              `Failed to fetch liquidated market keys for network ${network}:`,
+              `Failed to fetch liquidated markets for network ${network}:`,
               networkError,
             );
-            fetchErrors.push(networkError); // Collect errors
+            fetchErrors.push(networkError);
           }
         }),
       );
 
       setLiquidatedMarketKeys(combinedLiquidatedKeys);
 
-      // Set overall error if any network fetch failed
       if (fetchErrors.length > 0) {
-        setError(fetchErrors[0]); // Or aggregate errors if needed
+        setError(fetchErrors[0]);
       }
     } catch (err) {
-      // Catch potential errors from Promise.all itself
-      console.error('Overall error fetching liquidations:', err);
+      console.error('Error fetching liquidated markets:', err);
       setError(err);
     } finally {
-      setLoading(false);
-      setIsRefetching(false);
+      if (isRefetch) {
+        setIsRefetching(false);
+      } else {
+        setLoading(false);
+      }
     }
-  }, []); // Dependencies: None needed directly, fetchers are self-contained
+  }, []);
 
   useEffect(() => {
     fetchLiquidations().catch(console.error);
   }, [fetchLiquidations]);
 
-  const refetch = useCallback(() => {
-    fetchLiquidations(true).catch(console.error);
-  }, [fetchLiquidations]);
-
-  return { loading, isRefetching, liquidatedMarketKeys, error, refetch };
+  return {
+    loading,
+    isRefetching,
+    liquidatedMarketKeys,
+    error,
+    refetch: async () => fetchLiquidations(true),
+  };
 };
 
 export default useLiquidations;

src/hooks/useMarketBorrows.ts

@@ -1,5 +1,5 @@
 import { useQuery } from '@tanstack/react-query';
-import { getMarketDataSource } from '@/config/dataSources';
+import { supportsMorphoApi } from '@/config/dataSources';
 import { fetchMorphoMarketBorrows } from '@/data-sources/morpho-api/market-borrows';
 import { fetchSubgraphMarketBorrows } from '@/data-sources/subgraph/market-borrows';
 import { SupportedNetworks } from '@/utils/networks';
@@ -20,37 +20,40 @@ export const useMarketBorrows = (
 ) => {
   const queryKey = ['marketBorrows', marketId, loanAssetId, network];
 
-  // Determine the data source
-  const dataSource = network ? getMarketDataSource(network) : null;
-
   const { data, isLoading, error, refetch } = useQuery<MarketActivityTransaction[] | null>({
     queryKey: queryKey,
     queryFn: async (): Promise<MarketActivityTransaction[] | null> => {
-      // Guard clauses
-      if (!marketId || !loanAssetId || !network || !dataSource) {
+      if (!marketId || !loanAssetId || !network) {
         return null;
       }
 
-      console.log(
-        `Fetching market borrows for market ${marketId} (loan asset ${loanAssetId}) on ${network} via ${dataSource}`,
-      );
+      let borrows: MarketActivityTransaction[] | null = null;
 
-      try {
-        if (dataSource === 'morpho') {
-          // Morpho API might only need marketId for borrows
-          return await fetchMorphoMarketBorrows(marketId);
-        } else if (dataSource === 'subgraph') {
-          return await fetchSubgraphMarketBorrows(marketId, loanAssetId, network);
+      // Try Morpho API first if supported
+      if (supportsMorphoApi(network)) {
+        try {
+          console.log(`Attempting to fetch borrows via Morpho API for ${marketId}`);
+          borrows = await fetchMorphoMarketBorrows(marketId);
+        } catch (morphoError) {
+          console.error(`Failed to fetch borrows via Morpho API:`, morphoError);
+          // Continue to Subgraph fallback
+        }
+      }
+
+      // If Morpho API failed or not supported, try Subgraph
+      if (!borrows) {
+        try {
+          console.log(`Attempting to fetch borrows via Subgraph for ${marketId}`);
+          borrows = await fetchSubgraphMarketBorrows(marketId, loanAssetId, network);
+        } catch (subgraphError) {
+          console.error(`Failed to fetch borrows via Subgraph:`, subgraphError);
+          borrows = null;
         }
-      } catch (fetchError) {
-        console.error(`Failed to fetch market borrows via ${dataSource}:`, fetchError);
-        return null;
       }
 
-      console.warn('Unknown market data source determined for borrows');
-      return null;
+      return borrows;
     },
-    enabled: !!marketId && !!loanAssetId && !!network && !!dataSource,
+    enabled: !!marketId && !!loanAssetId && !!network,
     staleTime: 1000 * 60 * 2, // 2 minutes
     placeholderData: (previousData) => previousData ?? null,
     retry: 1,
@@ -62,7 +65,6 @@ export const useMarketBorrows = (
     isLoading: isLoading,
     error: error,
     refetch: refetch,
-    dataSource: dataSource,
   };
 };