@1delta/margin-fetcher 0.0.66 → 0.0.67

package/dist/index.js

@@ -19993,121 +19993,65 @@ var getChainLinkKeys = (chainId) => {
 
 // src/prices/pendle/fetchPendlePrices.ts
 var PENDLE_API_BASE = "https://api-v2.pendle.finance/core";
-var MARKETS_ENDPOINT = (chainId) => `${PENDLE_API_BASE}/v1/${chainId}/markets/active`;
-var PRICES_ENDPOINT = (chainId, type = "SY") => `${PENDLE_API_BASE}/v1/${chainId}/assets/prices?&type=${type}`;
-var SUPPORTED_CHAINS = [
-  // '1', Disabled for now
-  "42161",
-  "10",
-  "56",
-  "8453",
-  "5000",
-  "146",
-  "80094"
-];
-var marketsCache = null;
+var MARKETS_ENDPOINT = `${PENDLE_API_BASE}/v1/markets/all`;
+var PRICES_ENDPOINT = (types) => `${PENDLE_API_BASE}/v1/prices/assets${types ? `?type=${types.join(",")}` : ""}`;
+var marketsCache = {};
 var marketsCacheTimestamp = 0;
 var MARKETS_CACHE_TTL = 5 * 60 * 1e3;
-async function fetchMarketsForChain(chainId) {
-  try {
-    const response = await fetch(MARKETS_ENDPOINT(chainId));
-    const data = await response.json();
-    return data.markets || [];
-  } catch (error) {
-    console.error(`Error fetching markets for chain ${chainId}:`, error);
-    return [];
-  }
-}
 async function fetchPendleMarkets() {
-  const now = Date.now();
-  if (marketsCache && now - marketsCacheTimestamp < MARKETS_CACHE_TTL) {
+  if (Object.keys(marketsCache).length && marketsCacheTimestamp > Date.now() - MARKETS_CACHE_TTL) {
     return marketsCache;
   }
   try {
-    const allMarkets = [];
-    const promises = [];
-    for (const chainId of SUPPORTED_CHAINS) {
-      const chainMarkets = fetchMarketsForChain(chainId);
-      promises.push(chainMarkets);
+    const response = await fetch(MARKETS_ENDPOINT);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch all markets data: ${response.status}`);
     }
-    const results = await Promise.all(promises);
-    allMarkets.push(...results.flat());
-    const result = { markets: allMarkets };
-    marketsCache = result;
-    marketsCacheTimestamp = now;
-    return result;
+    const data = await response.json();
+    const marketsByChain = {};
+    if (data.markets) {
+      for (const market of data.markets) {
+        const chainId = market.chainId.toString();
+        if (!marketsByChain[chainId]) {
+          marketsByChain[chainId] = [];
+        }
+        marketsByChain[chainId].push(market);
+      }
+    }
+    marketsCache = marketsByChain;
+    marketsCacheTimestamp = Date.now();
+    return marketsByChain;
   } catch (error) {
-    console.error("Error fetching Pendle markets:", error);
-    return marketsCache || { markets: [] };
+    console.error("Error fetching all markets data:", error);
+    return {};
   }
 }
-async function fetchPendlePricesForChain(chainId, type = "all") {
+async function fetchPendlePricesForAllChain(lists = {}, assetType = ["YT", "PT"]) {
   try {
-    const types = type === "all" ? ["PT", "YT", "SY", "PENDLE_LP"] : [type];
-    let allPrices = {};
-    try {
-      const response = await fetch(PRICES_ENDPOINT(chainId, types.join(",")));
-      const data = await response.json();
-      allPrices = data.prices;
-    } catch (error) {
-      console.error(`Error fetching prices for chain ${chainId}:`, error);
-    }
-    return allPrices;
+    const response = await fetch(PRICES_ENDPOINT(assetType));
+    const data = await response.json();
+    let prices = {};
+    Object.entries(data.prices).forEach(([key, val]) => {
+      const [chainId, address] = key.split("-");
+      const assetKey = lists[chainId]?.list?.[address.toLowerCase()]?.assetGroup ?? key;
+      prices[assetKey] = val;
+    });
+    return prices;
   } catch (error) {
-    console.error(`Error fetching Pendle prices for chain ${chainId}:`, error);
+    console.error(`Error fetching prices pendle prices:`, error);
     return {};
   }
 }
-function extractTokenAddressesFromMarkets(markets) {
-  const tokensByChain = {};
-  markets.forEach((market) => {
-    const chain = market.pt?.split("-")[0];
-    if (chain && !tokensByChain[chain]) {
-      tokensByChain[chain] = { pt: [], yt: [], sy: [] };
-    }
-    if (market.pt && chain) {
-      const address = market.pt.split("-")[1];
-      if (address && !tokensByChain[chain].pt.includes(address)) {
-        tokensByChain[chain].pt.push(address);
-      }
-    }
-    if (market.yt && chain) {
-      const address = market.yt.split("-")[1];
-      if (address && !tokensByChain[chain].yt.includes(address)) {
-        tokensByChain[chain].yt.push(address);
-      }
-    }
-    if (market.sy && chain) {
-      const address = market.sy.split("-")[1];
-      if (address && !tokensByChain[chain].sy.includes(address)) {
-        tokensByChain[chain].sy.push(address);
-      }
-    }
-  });
-  return tokensByChain;
-}
-async function fetchPendlePrices() {
+async function fetchPendlePrices(lists = {}) {
   try {
     const marketsResponse = await fetchPendleMarkets();
-    if (!marketsResponse.markets.length) {
+    if (!Object.keys(marketsResponse).length) {
       return {};
     }
-    const tokensByChain = extractTokenAddressesFromMarkets(
-      marketsResponse.markets
+    const allPrices = await fetchPendlePricesForAllChain(lists);
+    return Object.fromEntries(
+      Object.entries(allPrices).filter(([, price]) => !!price)
     );
-    const allPrices = {};
-    for (const chainId of SUPPORTED_CHAINS) {
-      if (tokensByChain[chainId]) {
-        const chainPrices = await fetchPendlePricesForChain(chainId, "YT");
-        Object.entries(chainPrices).forEach(([address, price]) => {
-          if (price !== 0) {
-            const prefixedAddress = `${chainId}-${address}`;
-            allPrices[prefixedAddress] = price;
-          }
-        });
-      }
-    }
-    return allPrices;
   } catch (error) {
     console.error("Error in fetchPendlePrices:", error);
     return {};
@@ -20281,7 +20225,7 @@ var fetchMainPrices = async (chainIds, rpcOverrides, lists = {}) => {
       }
     };
   });
-  const otherDataPromises = [fetchDefillamaData(), fetchPendlePrices()];
+  const otherDataPromises = [fetchDefillamaData(), fetchPendlePrices(lists)];
   const [chainResults, ...otherResults] = await Promise.all([
     Promise.all(multicallPromises),
     ...otherDataPromises