@1delta/margin-fetcher 0.0.283 → 0.0.285

package/dist/index.js

@@ -9021,6 +9021,7 @@ var INIT_POOL_NAME_OVERRIDES = {
   "0x592c91ac727da556dc90ddf5630e1901efcd0c92": "Init FBTC Isolated"
 };
 var INIT_DEFAULT_LIQUIDATION_PENALTY = 0.05;
+var INIT_POOLS_FROZEN = true;
 var INIT_EMODE_LABELS = {
   [1]: "Default",
   [2]: "Blue Chip Volatile",
@@ -9095,8 +9096,12 @@ var getInitReservesDataConverter = (lender, chainId, prices, additionalYields, t
           rewards: [],
           config: {},
           closeFactor: 1,
-          borrowingEnabled: totalDebt !== "0",
-          depositsEnabled: true,
+          // Reserve still exists (positions must remain visible & withdrawable);
+          // only new deposits/borrows are blocked → active but frozen.
+          isActive: true,
+          isFrozen: INIT_POOLS_FROZEN,
+          borrowingEnabled: false ,
+          depositsEnabled: !INIT_POOLS_FROZEN,
           params
         };
       });
@@ -22004,68 +22009,100 @@ function createCompoundV2Entry(i, data, key, assetsIn, vToken, meta, claimableRe
   };
 }
 
+// src/lending/user-data/euler/eulerDataApi.ts
+var EULER_DATA_API_BASE = "https://v3.euler.finance/v3";
+var EULER_API_REQUEST_TIMEOUT_MS = 1e4;
+var EULER_API_CHAINS = /* @__PURE__ */ new Set([
+  "1",
+  // Ethereum
+  "56",
+  // BSC
+  "130",
+  // Unichain
+  "146",
+  // Sonic
+  "239",
+  // TAC
+  "999",
+  // HyperEVM
+  "1923",
+  // Swell
+  "8453",
+  // Base
+  "9745",
+  // Plasma
+  "42161",
+  // Arbitrum
+  "43114",
+  // Avalanche
+  "60808",
+  // BOB
+  "80094"
+  // Berachain
+]);
+var eulerApiSupportsChain = (chainId) => EULER_API_CHAINS.has(chainId);
+async function fetchEulerPositionsFromApi(chainId, owner, forceFresh = true) {
+  if (!eulerApiSupportsChain(chainId)) return void 0;
+  const controller = new AbortController();
+  const timeout = setTimeout(
+    () => controller.abort(),
+    EULER_API_REQUEST_TIMEOUT_MS
+  );
+  try {
+    const positions = [];
+    const limit = 100;
+    let offset = 0;
+    for (let page = 0; page < 10; page++) {
+      const url = `${EULER_DATA_API_BASE}/accounts/${owner.toLowerCase()}/positions?chainId=${chainId}&forceFresh=${forceFresh}&limit=${limit}&offset=${offset}`;
+      const response = await fetch(url, { signal: controller.signal });
+      if (!response.ok) return offset === 0 ? void 0 : positions;
+      const body = await response.json();
+      const page_ = body?.data ?? [];
+      positions.push(...page_);
+      const total = body?.meta?.total;
+      offset += limit;
+      if (page_.length < limit || typeof total === "number" && offset >= total)
+        break;
+    }
+    return positions;
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
 // src/lending/user-data/euler/userCallBuild.ts
-Array.from(
+var ALL_EULER_SUB_ACCOUNT_INDEXES = Array.from(
   { length: 256 },
   (_3, i) => i
 );
-var EULER_SUBGRAPH_BASE = "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs";
-var EULER_SUBGRAPH_URLS = {
-  "1": `${EULER_SUBGRAPH_BASE}/euler-v2-mainnet/latest/gn`,
-  "10": `${EULER_SUBGRAPH_BASE}/euler-v2-optimism/latest/gn`,
-  "56": `${EULER_SUBGRAPH_BASE}/euler-v2-bsc/latest/gn`,
-  "100": `${EULER_SUBGRAPH_BASE}/euler-v2-gnosis/latest/gn`,
-  "130": `${EULER_SUBGRAPH_BASE}/euler-v2-unichain/latest/gn`,
-  "146": `${EULER_SUBGRAPH_BASE}/euler-v2-sonic/latest/gn`,
-  "239": `${EULER_SUBGRAPH_BASE}/euler-v2-tac/latest/gn`,
-  "480": `${EULER_SUBGRAPH_BASE}/euler-v2-worldchain/latest/gn`,
-  "999": `${EULER_SUBGRAPH_BASE}/euler-v2-hyperevm/latest/gn`,
-  "1923": `${EULER_SUBGRAPH_BASE}/euler-v2-swell/latest/gn`,
-  "5000": `${EULER_SUBGRAPH_BASE}/euler-v2-mantle/latest/gn`,
-  "8453": `${EULER_SUBGRAPH_BASE}/euler-v2-base/latest/gn`,
-  "9745": `${EULER_SUBGRAPH_BASE}/euler-v2-plasma/latest/gn`,
-  "42161": `${EULER_SUBGRAPH_BASE}/euler-v2-arbitrum/latest/gn`,
-  "43114": `${EULER_SUBGRAPH_BASE}/euler-v2-avalanche/latest/gn`,
-  "57073": `${EULER_SUBGRAPH_BASE}/euler-v2-ink/latest/gn`,
-  "60808": `${EULER_SUBGRAPH_BASE}/euler-v2-bob/latest/gn`,
-  "80094": `${EULER_SUBGRAPH_BASE}/euler-v2-berachain/latest/gn`
-};
-var SUBGRAPH_CACHE_TTL_MS = 3e4;
-var subgraphCache = /* @__PURE__ */ new Map();
-function fetchEulerSubAccountIndexes(chainId, owner) {
+var ACCOUNT_CACHE_TTL_MS = 5e3;
+var accountCache = /* @__PURE__ */ new Map();
+function indexesFromApiPositions(positions, owner) {
+  const set = /* @__PURE__ */ new Set();
+  for (const p of positions) {
+    if (p.account) set.add(getSubAccountIndex(p.account, owner));
+  }
+  if (set.size === 0) set.add(0);
+  return [...set];
+}
+function fetchEulerActiveIndexesViaApi(chainId, owner) {
   const key = `${chainId}:${owner.toLowerCase()}`;
-  const cached = subgraphCache.get(key);
+  const cached = accountCache.get(key);
   if (cached) return cached.promise;
-  const promise = fetchSubAccountsFromSubgraph(chainId, owner).then((idxs) => idxs.length > 0 ? idxs : [0]).catch(() => [0]);
-  const timer = setTimeout(
-    () => subgraphCache.delete(key),
-    SUBGRAPH_CACHE_TTL_MS
-  );
-  subgraphCache.set(key, { promise, timer });
+  const promise = fetchEulerPositionsFromApi(chainId, owner).then(
+    (positions) => positions === void 0 ? void 0 : indexesFromApiPositions(positions, owner)
+  ).catch(() => void 0);
+  const timer = setTimeout(() => accountCache.delete(key), ACCOUNT_CACHE_TTL_MS);
+  accountCache.set(key, { promise, timer });
   return promise;
 }
-async function fetchSubAccountsFromSubgraph(chainId, owner) {
-  const url = EULER_SUBGRAPH_URLS[chainId];
-  if (!url) return [0];
-  const query3 = `{
-  accounts(first: 100, where: { owner: "${owner.toLowerCase()}" }) {
-    id
-    subAccount
-  }
-}`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ query: query3 })
-  });
-  if (!response.ok) return [0];
-  const data = await response.json();
-  const accounts = data?.data?.accounts;
-  if (!accounts || accounts.length === 0) return [0];
-  return accounts.map((a) => {
-    const addr = a.subAccount || a.id;
-    return getSubAccountIndex(addr, owner);
-  });
+async function fetchEulerSubAccountIndexes(chainId, owner) {
+  return await fetchEulerActiveIndexesViaApi(chainId, owner) ?? [0];
+}
+async function resolveEulerBuildIndexes(chainId, owner) {
+  return await fetchEulerActiveIndexesViaApi(chainId, owner) ?? ALL_EULER_SUB_ACCOUNT_INDEXES;
 }
 var RESOLVED_STORE_TTL_MS = 6e4;
 var resolvedIndexesStore = /* @__PURE__ */ new Map();
@@ -22107,7 +22144,7 @@ var buildEulerUserCall = async (chainId, lender, account, subAccountIndexes) =>
   const accountLensAddress = config.accountLens;
   const evcAddress = config.evc;
   if (!accountLensAddress || !evcAddress) return [];
-  const indexes = subAccountIndexes ?? await fetchEulerSubAccountIndexes(chainId, account);
+  const indexes = subAccountIndexes ?? await resolveEulerBuildIndexes(chainId, account);
   const sortedIndices = resolveSubAccountIndexes(account, indexes);
   storeResolvedIndexes(chainId, account, indexes);
   return sortedIndices.map((i) => ({
@@ -22311,16 +22348,16 @@ var buildGearboxV3UserCall = (chainId, _lender, account) => {
 };
 
 // src/lending/user-data/dolomite/userCallBuild.ts
-var SUBGRAPH_CACHE_TTL_MS2 = 3e4;
+var SUBGRAPH_CACHE_TTL_MS = 3e4;
 var SUBGRAPH_TIMEOUT_MS2 = 1e4;
-var subgraphCache2 = /* @__PURE__ */ new Map();
+var subgraphCache = /* @__PURE__ */ new Map();
 function fetchDolomiteAccountNumbers(chainId, owner) {
   const key = `${chainId}:${owner.toLowerCase()}`;
-  const cached = subgraphCache2.get(key);
+  const cached = subgraphCache.get(key);
   if (cached) return cached.promise;
   const promise = fetchAccountNumbersFromSubgraph(chainId, owner).then((ns) => dedupeWithDefault(ns)).catch(() => ["0"]);
-  const timer = setTimeout(() => subgraphCache2.delete(key), SUBGRAPH_CACHE_TTL_MS2);
-  subgraphCache2.set(key, { promise, timer });
+  const timer = setTimeout(() => subgraphCache.delete(key), SUBGRAPH_CACHE_TTL_MS);
+  subgraphCache.set(key, { promise, timer });
   return promise;
 }
 function dedupeWithDefault(numbers) {
@@ -24845,6 +24882,72 @@ var multicallViemAbiArray = async (chainId, abi, calls, getEvmClient16, retry =
     );
   }
 };
+var multicallShardedAbiArray = async (chainId, abi, calls, getEvmClient16, poolSize, retries = maxRetries, allowFailure = true, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, logs = false) => {
+  if (poolSize <= 1) {
+    return multicallViemAbiArray(
+      chainId,
+      abi,
+      calls,
+      getEvmClient16,
+      true,
+      0,
+      retries,
+      allowFailure,
+      batchSize,
+      logs
+    );
+  }
+  const abiIsArray = isArray(abi[0]);
+  const contracts = calls.map(({ address, name, params }, i) => ({
+    abi: abiIsArray ? abi?.[i] : abi,
+    address,
+    functionName: name,
+    args: params
+  }));
+  const batches = [];
+  for (let i = 0; i < contracts.length; i += batchSize) {
+    batches.push({ start: i, items: contracts.slice(i, i + batchSize) });
+  }
+  const results = new Array(contracts.length);
+  const runBatch = async (batch, rpcId, attemptsLeft, size) => {
+    try {
+      const provider = getEvmClient16(chainId, rpcId);
+      const returnData = await provider.multicall({
+        allowFailure,
+        batchSize: size,
+        contracts: batch.items
+      });
+      const mapped = allowFailure ? returnData.map(
+        ({ result, status }) => status !== "success" ? "0x" : result
+      ) : returnData;
+      for (let j = 0; j < mapped.length; j++) {
+        results[batch.start + j] = mapped[j];
+      }
+    } catch (error) {
+      if (logs) console.log("error in sharded multicall batch", error);
+      if (attemptsLeft <= 0) throw error;
+      return runBatch(
+        batch,
+        rpcId + 1,
+        attemptsLeft - 1,
+        Math.max(1, Math.floor(size / 2))
+      );
+    }
+  };
+  const workers = Math.max(1, Math.min(poolSize, batches.length));
+  let cursor = 0;
+  const worker = async (workerId) => {
+    while (true) {
+      const idx = cursor++;
+      if (idx >= batches.length) break;
+      await runBatch(batches[idx], workerId, retries, batchSize);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: workers }, (_3, w) => worker(w))
+  );
+  return results;
+};
 function prepareMulticallInputs(abi, calls) {
   const abiIsArray = isArray(abi[0]);
   return calls.map(({ address, name, params }, i) => ({
@@ -29435,7 +29538,7 @@ function unflattenLenderData(pools) {
   }
   return result;
 }
-var getLenderUserDataResult = async (chainId, queriesRaw, getEvmClient16, allowFailure = true, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, retries = 3, logs = false) => {
+var getLenderUserDataResult = async (chainId, queriesRaw, getEvmClient16, allowFailure = true, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, retries = 3, logs = false, concurrency = 1) => {
   const queries = organizeUserQueries(queriesRaw);
   const builtCalls = await Promise.all(
     queries.map(async (query3) => {
@@ -29451,13 +29554,12 @@ var getLenderUserDataResult = async (chainId, queriesRaw, getEvmClient16, allowF
     })
   );
   const calls = builtCalls.flat();
-  return await multicallViemAbiArray(
+  return await multicallShardedAbiArray(
     chainId,
     calls.map((call) => call.abi),
     calls.map((call) => call.call),
     getEvmClient16,
-    true,
-    0,
+    concurrency,
     retries,
     allowFailure,
     batchSize,
@@ -32887,6 +32989,62 @@ var coreLstFetcher = {
   }
 };
 
+// src/yields/intrinsic/fetchers/hastra.ts
+var HASTRA_POR_URL = "https://www.hastra.io/hastra-pulse/public/api/v1/por";
+var HASTRA_PRIME_KEY = "Hastra PRIME::PRIME";
+var hastraPrimeFetcher = {
+  label: "Hastra",
+  fetch: async () => {
+    const res = await fetch(HASTRA_POR_URL, {
+      method: "GET",
+      headers: { Accept: "application/json" }
+    }).then((r) => r.json());
+    const card = res?.demo_prime_card ?? {};
+    const current = Number(card.current_rate);
+    const fee = Number(card.fee);
+    const lifetimePct = Number(card.lifetime_average_rate) * 100;
+    let apr;
+    if (Number.isFinite(current)) {
+      apr = current - (Number.isFinite(fee) ? fee : 0);
+    } else if (Number.isFinite(lifetimePct)) {
+      apr = lifetimePct;
+    } else {
+      apr = 0;
+    }
+    return { [HASTRA_PRIME_KEY]: Math.max(0, apr) };
+  }
+};
+
+// src/yields/intrinsic/fetchers/lombard.ts
+var LBTC_APY_URL = "https://mainnet.prod.lombard.finance/api/v1/analytics/estimated-apy";
+var lombardLbtcFetcher = {
+  label: "LBTC",
+  fetch: async () => {
+    const res = await fetch(LBTC_APY_URL, {
+      headers: { accept: "application/json" }
+    }).then((r) => r.json());
+    const frac = Number(res?.lbtc_estimated_apy);
+    return { LBTC: Number.isFinite(frac) ? frac * 100 : 0 };
+  }
+};
+var LOMBARD_VAULT_APY_URL = "https://mainnet.prod.lombard.finance/api/v1/analytics/vault/apy/history";
+var createLombardVaultFetcher = (wrapper, key) => ({
+  label: `LOMBARD_VAULT:${wrapper}`,
+  fetch: async () => {
+    const url = `${LOMBARD_VAULT_APY_URL}?vault_wrapper=${wrapper}&interval=APY_INTERVAL_1M`;
+    const res = await fetch(url, {
+      headers: { accept: "application/json" }
+    }).then((r) => r.json());
+    const latest = Array.isArray(res?.snapshots) ? res.snapshots[0] : void 0;
+    const frac = Number(latest?.total_apy);
+    return { [key]: Number.isFinite(frac) ? frac * 100 : 0 };
+  }
+});
+var lombardLbtcvFetcher = createLombardVaultFetcher(
+  "VAULT_WRAPPER_BTCE",
+  "LBTCv"
+);
+
 // src/yields/intrinsic/index.ts
 async function fetchIntrinsicYields() {
   const wstethPromise = safeFetch(wstethFetcher.label, wstethFetcher.fetch);
@@ -32955,7 +33113,10 @@ async function fetchIntrinsicYields() {
     beraEthFetcher,
     lbgtFetcher,
     psxdcFetcher,
-    coreLstFetcher
+    coreLstFetcher,
+    hastraPrimeFetcher,
+    lombardLbtcFetcher,
+    lombardLbtcvFetcher
   ];
   const results = await Promise.all([
     wstethPromise,
@@ -37994,6 +38155,7 @@ var EULER_EARN_SUBGRAPH_URLS = {
   [Chain.AVALANCHE_C_CHAIN]: eulerSubgraphUrl("euler-v2-avalanche")
 };
 var hasEulerEarnVaultSubgraph = (chainId) => chainId in EULER_EARN_SUBGRAPH_URLS;
+var getEulerEarnSubgraphUrl = (chainId) => EULER_EARN_SUBGRAPH_URLS[chainId];
 var EULER_EARN_VAULTS_QUERY = `
 {
   eulerEarnVaults(first: 200, skip: 0) {
@@ -38222,10 +38384,176 @@ async function fetchEulerEarnVaultsFromSubgraph(chainId, prices = {}, tokenList
   }
   return out;
 }
+var EULER_DATA_API_BASE2 = "https://v3.euler.finance/v3";
+var API_TIMEOUT_MS = 1e4;
+var DETAIL_CONCURRENCY = 8;
+var BLOCK_TIME_SEC = {
+  "1": 12,
+  "56": 0.75,
+  "130": 1,
+  "146": 0.5,
+  "8453": 2,
+  "1923": 2,
+  "42161": 0.25,
+  "43114": 2
+};
+var DEFAULT_BLOCK_TIME_SEC = 2;
+var MAX_LAG_SECONDS = 30 * 60;
+function safeBigInt2(v) {
+  if (v == null || v === "") return 0n;
+  try {
+    return BigInt(typeof v === "number" ? Math.trunc(v) : v);
+  } catch {
+    return 0n;
+  }
+}
+async function getJson(url) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, { signal: controller.signal });
+    if (!res.ok) return void 0;
+    return await res.json();
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function isEulerEarnSubgraphStale(chainId, subgraphUrl) {
+  const [subHead, chainHead] = await Promise.all([
+    fetchSubgraphHead(subgraphUrl),
+    getEvmClientUniversal({ chain: chainId, rpcId: 0 }).getBlockNumber().then((b) => Number(b)).catch(() => null)
+  ]);
+  if (subHead == null || chainHead == null) return false;
+  const lagBlocks = chainHead - subHead;
+  if (lagBlocks <= 0) return false;
+  const lagSeconds = lagBlocks * (BLOCK_TIME_SEC[chainId] ?? DEFAULT_BLOCK_TIME_SEC);
+  return lagSeconds > MAX_LAG_SECONDS;
+}
+async function fetchSubgraphHead(subgraphUrl) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
+  try {
+    const res = await fetch(subgraphUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query: "{ _meta { block { number } } }" }),
+      signal: controller.signal
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    const n = json?.data?._meta?.block?.number;
+    return typeof n === "number" ? n : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function mapApiDetail(d, chainId, prices, tokenList) {
+  const address = (d.address ?? "").toLowerCase();
+  const underlying = (d.asset?.address ?? "").toLowerCase();
+  if (!address || !underlying) return null;
+  const assetMeta = tokenList[underlying];
+  const decimals = Number(d.decimals ?? d.asset?.decimals ?? 18);
+  const totalAssetsRaw = String(d.totalAssets ?? "0");
+  const totalSupplyRaw = String(d.totalShares ?? "0");
+  const convertToAssets = d.exchangeRate != null ? String(d.exchangeRate) : deriveConvertToAssets(totalAssetsRaw, totalSupplyRaw, decimals);
+  const supplyRate = Number(d.supplyApy ?? d.apyCurrent ?? 0) || 0;
+  const availableRaw = safeBigInt2(d.availableAssets) || safeBigInt2(totalAssetsRaw);
+  const totalAssetsBig = safeBigInt2(totalAssetsRaw);
+  const liquidityRaw = (availableRaw > totalAssetsBig ? totalAssetsBig : availableRaw).toString();
+  const totalAssetsFormatted = Number(parseRawAmount(totalAssetsRaw, decimals));
+  const liquidityFormatted = Number(parseRawAmount(liquidityRaw, decimals));
+  const oracleKey = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(underlying, chainId);
+  const priceUsd = prices[oracleKey] ?? prices[underlying] ?? 0;
+  const totalAssetsUsd = priceUsd ? totalAssetsFormatted * priceUsd : Number(d.totalSupplyUsd ?? 0);
+  const liquidityUsd = priceUsd ? liquidityFormatted * priceUsd : Number(d.availableAssetsUsd ?? 0);
+  return {
+    address,
+    underlying,
+    symbol: d.symbol ?? "",
+    name: d.name ?? "",
+    decimals,
+    totalAssets: totalAssetsRaw,
+    totalSupply: totalSupplyRaw,
+    convertToAssets,
+    supplyRate,
+    rewardsRate: 0,
+    depositRate: supplyRate,
+    // The API doesn't surface the performance fee on this endpoint; the
+    // headline APY is already net, so 0 here only affects fee display.
+    fee: 0,
+    owner: d.owner?.toLowerCase(),
+    curator: d.curator?.toLowerCase(),
+    curatorName: curatorNameFromVaultName(d.name, assetMeta?.symbol),
+    guardian: d.guardian?.toLowerCase(),
+    feeRecipient: d.feeReceiver?.toLowerCase() || void 0,
+    asset: assetMeta,
+    priceUsd: priceUsd || void 0,
+    totalAssetsFormatted,
+    totalAssetsUsd,
+    liquidity: liquidityRaw,
+    liquidityFormatted,
+    liquidityUsd
+  };
+}
+async function mapWithConcurrency(items, limit, fn) {
+  const out = new Array(items.length);
+  let cursor = 0;
+  const worker = async () => {
+    while (true) {
+      const i = cursor++;
+      if (i >= items.length) break;
+      out[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => worker())
+  );
+  return out;
+}
+async function fetchEulerEarnVaultsFromApi(chainId, prices = {}, tokenList = {}) {
+  const list = await getJson(
+    `${EULER_DATA_API_BASE2}/earn/vaults?chainId=${chainId}&limit=200`
+  );
+  if (!list) return void 0;
+  const rows = list.data ?? [];
+  if (rows.length === 0) return {};
+  const details = await mapWithConcurrency(
+    rows,
+    DETAIL_CONCURRENCY,
+    (row) => getJson(
+      `${EULER_DATA_API_BASE2}/earn/vaults/${chainId}/${row.address}?include=strategies`
+    ).then((d) => d?.data)
+  );
+  const out = {};
+  for (const d of details) {
+    if (!d) continue;
+    const v = mapApiDetail(d, chainId, prices, tokenList);
+    if (v) out[v.address] = v;
+  }
+  return out;
+}
 
 // src/vaults/euler-earn/fetchPublic.ts
+var isNonEmpty = (v) => !!v && Object.keys(v).length > 0;
 var fetchEulerEarnVaults = async (chainId, prices = {}, tokenList = {}) => {
-  return fetchEulerEarnVaultsFromSubgraph(chainId, prices, tokenList);
+  const subgraphUrl = getEulerEarnSubgraphUrl(chainId);
+  if (!subgraphUrl) {
+    return await fetchEulerEarnVaultsFromApi(chainId, prices, tokenList) ?? {};
+  }
+  const [stale, subgraph] = await Promise.all([
+    isEulerEarnSubgraphStale(chainId, subgraphUrl).catch(() => false),
+    fetchEulerEarnVaultsFromSubgraph(chainId, prices, tokenList).then((r) => ({ ok: true, data: r })).catch(() => ({ ok: false, data: void 0 }))
+  ]);
+  if (!stale && subgraph.ok && isNonEmpty(subgraph.data)) {
+    return subgraph.data;
+  }
+  const fromApi = await fetchEulerEarnVaultsFromApi(chainId, prices, tokenList);
+  if (isNonEmpty(fromApi)) return fromApi;
+  return subgraph.ok && subgraph.data ? subgraph.data : {};
 };
 var CHAIN_ID4 = "1";
 var SWBTC = "0x8db2350d78abc13f5673a411d4700bcf87864dde";
@@ -38356,36 +38684,6 @@ var stceloFetcher = {
     return { STCELO: apr };
   }
 };
-
-// src/yields/intrinsic/fetchers/lombard.ts
-var LBTC_APY_URL = "https://mainnet.prod.lombard.finance/api/v1/analytics/estimated-apy";
-var lombardLbtcFetcher = {
-  label: "LBTC",
-  fetch: async () => {
-    const res = await fetch(LBTC_APY_URL, {
-      headers: { accept: "application/json" }
-    }).then((r) => r.json());
-    const frac = Number(res?.lbtc_estimated_apy);
-    return { LBTC: Number.isFinite(frac) ? frac * 100 : 0 };
-  }
-};
-var LOMBARD_VAULT_APY_URL = "https://mainnet.prod.lombard.finance/api/v1/analytics/vault/apy/history";
-var createLombardVaultFetcher = (wrapper, key) => ({
-  label: `LOMBARD_VAULT:${wrapper}`,
-  fetch: async () => {
-    const url = `${LOMBARD_VAULT_APY_URL}?vault_wrapper=${wrapper}&interval=APY_INTERVAL_1M`;
-    const res = await fetch(url, {
-      headers: { accept: "application/json" }
-    }).then((r) => r.json());
-    const latest = Array.isArray(res?.snapshots) ? res.snapshots[0] : void 0;
-    const frac = Number(latest?.total_apy);
-    return { [key]: Number.isFinite(frac) ? frac * 100 : 0 };
-  }
-});
-var lombardLbtcvFetcher = createLombardVaultFetcher(
-  "VAULT_WRAPPER_BTCE",
-  "LBTCv"
-);
 var CHAIN_ID6 = "1284";
 var STDOT = "0xbc7e02c4178a7df7d3e564323a5c359dc96c4db4";
 var ONE_E185 = 10n ** 18n;
@@ -44832,6 +45130,28 @@ var SINGLE_CHAIN_ENTRIES = {
       withdrawalCooldownSeconds: 604800,
       yieldFetcher: mapleFetcher,
       yieldKey: "SYRUPUSDT"
+    },
+    {
+      // Hastra Democratized PRIME — ERC-4626 over wYLDS (itself ERC-4626 over
+      // USDC), so the share/asset ratio accrues on-chain (`convertToAssets`).
+      // Solana-primary; the Ethereum deployment exists (verified on-chain:
+      // symbol PRIME, 6 decimals, asset() = wYLDS) but carries no user holders
+      // yet. Deposits are whitelist-gated, so `isMintable` is false — we list
+      // + price it, but don't advertise a permissionless mint that would
+      // revert. Two-phase exit (`requestRedeem` → `completeRedeem`). APR from
+      // the public Proof-of-Reserve feed via `hastraPrimeFetcher`.
+      address: "0x19ebb35279a16207ec4ba82799cc64715065f7f6",
+      underlying: "0x6ad038ca6c04e885630851278ca0a856ad9a66cc",
+      // wYLDS
+      symbol: "PRIME",
+      brand: "Hastra",
+      decimals: 6,
+      underlyingDecimals: 6,
+      isRebasing: false,
+      isMintable: false,
+      withdrawalMode: "request-based",
+      yieldFetcher: hastraPrimeFetcher,
+      yieldKey: "Hastra PRIME::PRIME"
     }
   ],
   "8453": [
@@ -45747,7 +46067,7 @@ var GMX_SUPPORTED_CHAINS = Object.keys(GMX_API_HOSTS);
 var getGmxApiHost = (chainId) => GMX_API_HOSTS[chainId];
 
 // src/vaults/gmx/api.ts
-var getJson = async (url) => {
+var getJson2 = async (url) => {
   const res = await fetch(url, {
     method: "GET",
     headers: { Accept: "application/json" }
@@ -45759,12 +46079,12 @@ var fetchGmxRawData = async (chainId, period, apiUrlOverride) => {
   const host = apiUrlOverride ?? getGmxApiHost(chainId);
   if (!host) throw new Error(`GMX not supported on chain ${chainId}`);
   const [apy, marketsRes, glvsRes, tokensRes] = await Promise.all([
-    getJson(`${host}/apy?period=${encodeURIComponent(period)}`),
-    getJson(`${host}/markets`).catch(() => ({
+    getJson2(`${host}/apy?period=${encodeURIComponent(period)}`),
+    getJson2(`${host}/markets`).catch(() => ({
       markets: []
     })),
-    getJson(`${host}/glvs`).catch(() => ({ glvs: [] })),
-    getJson(`${host}/tokens`).catch(() => ({
+    getJson2(`${host}/glvs`).catch(() => ({ glvs: [] })),
+    getJson2(`${host}/tokens`).catch(() => ({
       tokens: []
     }))
   ]);