@continuumdao/ctm-mpc-defi 0.2.31 → 0.2.32

package/dist/agent/catalog.cjs

@@ -24,6 +24,9 @@ var __export = (target, all) => {
 function getAaveGraphqlProxyUrl() {
   return aaveGraphqlProxyUrl;
 }
+function getEulerGraphqlProxyUrl() {
+  return eulerGraphqlProxyUrl;
+}
 function getMorphoGraphqlProxyUrl() {
   return morphoGraphqlProxyUrl;
 }
@@ -61,7 +64,7 @@ async function getJsonViaOptionalProxy(args) {
   }
   return await r.json();
 }
-var aaveGraphqlProxyUrl, morphoGraphqlProxyUrl;
+var aaveGraphqlProxyUrl, eulerGraphqlProxyUrl, morphoGraphqlProxyUrl;
 var init_defiProxy = __esm({
   "src/core/defiProxy.ts"() {
   }
@@ -671,9 +674,9 @@ async function loadFullCurveSessionForRpc(rpcUrl) {
   if (!url) {
     throw new Error("rpcUrl is required.");
   }
-  const cached = curveSessionCache.get(url);
-  if (cached && cached.expiresAt > Date.now()) {
-    return cached.session;
+  const cached2 = curveSessionCache.get(url);
+  if (cached2 && cached2.expiresAt > Date.now()) {
+    return cached2.session;
   }
   try {
     const { default: curve } = await import('@curvefi/api');
@@ -7070,6 +7073,242 @@ var aaveV4ProtocolModule = {
   ]
 };
 registerProtocolModule(aaveV4ProtocolModule);
+init_defiProxy();
+var EULER_EVAULT_CAP_UNLIMITED_WEI = (1n << 256n) - 1n;
+var UINT256_MAX = EULER_EVAULT_CAP_UNLIMITED_WEI;
+viem.parseAbi([
+  "function caps() view returns (uint16 supplyCap, uint16 borrowCap)",
+  "function cash() view returns (uint256)",
+  "function totalBorrows() view returns (uint256)",
+  "function totalAssets() view returns (uint256)"
+]);
+function resolveEulerAmountCapToWei(rawCap16) {
+  const amountCap = BigInt(rawCap16) & 0xffffn;
+  if (amountCap === 0n) return UINT256_MAX;
+  const exp = amountCap & 63n;
+  const mantissa = amountCap >> 6n;
+  return 10n ** exp * mantissa / 100n;
+}
+function eulerSubgraphVaultCapToUnderlyingWei(raw) {
+  try {
+    const v = BigInt((raw ?? "").trim() || "0");
+    if (v >= UINT256_MAX - 3n) return v;
+    if (v <= 0xffffn) return resolveEulerAmountCapToWei(v);
+    return v;
+  } catch {
+    return 0n;
+  }
+}
+
+// src/protocols/evm/euler-v2/eulerV2Subgraph.ts
+var EULER_V2_GOLDSKY_SUBGRAPH_URL_BY_CHAIN_ID = {
+  1: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-mainnet/latest/gn",
+  8453: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-base/latest/gn",
+  1923: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-swell/latest/gn",
+  146: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-sonic/latest/gn",
+  60808: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-bob/latest/gn",
+  80094: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-berachain/latest/gn",
+  43114: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-avalanche/latest/gn",
+  42161: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-arbitrum/latest/gn",
+  130: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-unichain/latest/gn",
+  57073: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-ink/latest/gn",
+  56: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-bsc/latest/gn",
+  999: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-hyperevm/latest/gn",
+  10: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-optimism/latest/gn",
+  100: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-gnosis/latest/gn",
+  480: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-worldchain/latest/gn",
+  239: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-tac/latest/gn",
+  9745: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-plasma/latest/gn",
+  5e3: "https://api.goldsky.com/api/public/project_cm4iagnemt1wp01xn4gh1agft/subgraphs/euler-v2-mantle/latest/gn"
+};
+var WRAPPED_NATIVE_FALLBACK = {
+  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+  10: "0x4200000000000000000000000000000000000006",
+  56: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+  100: "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d",
+  130: "0x4200000000000000000000000000000000000006",
+  146: "0x03980325872071166574bcd94670450917897468",
+  239: "0xB63B9f0eb4A6E6f191529D71d4D88cc8900Df2C9",
+  // TAC: WTAC (https://docs.tac.build/ecosystem/token-list)
+  480: "0x4200000000000000000000000000000000000006",
+  999: "0x5555555555555555555555555555555555555555",
+  // HyperEVM: WHYPE (Hyperliquid docs)
+  1923: "0x4200000000000000000000000000000000000006",
+  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+  43114: "0xB31f66AA3C1e785363F0875A1B74D27b85FE0459",
+  5e3: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8",
+  // Mantle: WMNT
+  57073: "0x4200000000000000000000000000000000000006",
+  60808: "0x4200000000000000000000000000000000000006",
+  80094: "0x6969696969696969696969696969696969696969",
+  // Berachain: WBERA (https://docs.berachain.com)
+  8453: "0x4200000000000000000000000000000000000006",
+  9745: "0x6100E367285b01F48D07953803A2d8dCA5D19873"
+  // Plasma: WXPL
+};
+for (const id of Object.keys(EULER_V2_GOLDSKY_SUBGRAPH_URL_BY_CHAIN_ID).map(Number)) {
+  if (WRAPPED_NATIVE_FALLBACK[id] == null) {
+    throw new Error(`eulerV2Subgraph: add WRAPPED_NATIVE_FALLBACK for Euler Goldsky chain ${id}`);
+  }
+}
+function eulerV2GoldskyUrlForChain(chainId) {
+  return EULER_V2_GOLDSKY_SUBGRAPH_URL_BY_CHAIN_ID[chainId];
+}
+async function resolveEulerWrappedNativeToken(chainId) {
+  try {
+    const fromAave = await fetchAaveV4NativeWrappedToken(chainId);
+    if (fromAave) return fromAave;
+  } catch {
+  }
+  const fb = WRAPPED_NATIVE_FALLBACK[chainId];
+  if (fb && viem.isAddress(fb)) return viem.getAddress(fb);
+  return null;
+}
+async function eulerSubgraphGql(endpoint, query, variables, chainId) {
+  const body = { query, variables: variables ?? {} };
+  const proxy = getEulerGraphqlProxyUrl();
+  const j = await postJsonViaOptionalProxy({
+    directUrl: endpoint,
+    body,
+    proxyUrl: proxy,
+    proxyEnvelope: chainId != null ? { chainId, query, variables: variables ?? {} } : body
+  });
+  if (j.errors?.length) {
+    throw new Error(j.errors.map((e) => e.message ?? "Unknown").join("; "));
+  }
+  if (j.data == null) throw new Error("Euler subgraph: empty response");
+  return j.data;
+}
+async function eulerV2QueryGraphQl(chainId, query, variables) {
+  const endpoint = eulerV2GoldskyUrlForChain(chainId);
+  if (!endpoint) {
+    throw new Error(`Euler v2 subgraph is not configured for chain ${chainId}`);
+  }
+  return eulerSubgraphGql(endpoint, query, variables, chainId);
+}
+function normAssetAddr(raw) {
+  const s = (raw ?? "").trim();
+  if (!s || !viem.isAddress(s)) return null;
+  return viem.getAddress(s).toLowerCase();
+}
+function vaultShowsBorrowTab(borrowCap, totalBorrows) {
+  let borrows = 0n;
+  try {
+    borrows = BigInt((totalBorrows ?? "").trim() || "0");
+  } catch {
+    borrows = 0n;
+  }
+  if (borrows > 0n) return true;
+  const w = eulerSubgraphVaultCapToUnderlyingWei(borrowCap);
+  if (w >= EULER_EVAULT_CAP_UNLIMITED_WEI - 3n) return true;
+  return w > 0n;
+}
+var VAULT_PAGE = `
+query V($first: Int!, $skip: Int!) {
+  eulerVaults(first: $first, skip: $skip) {
+    asset
+    borrowCap
+    state { totalBorrows }
+  }
+}
+`;
+var EARN_PAGE = `
+query E($first: Int!, $skip: Int!) {
+  eulerEarnVaults(first: $first, skip: $skip) {
+    asset
+  }
+}
+`;
+async function paginateEulerVaultRows(chainId) {
+  const out = [];
+  let skip = 0;
+  const first = 1e3;
+  while (true) {
+    const d = await eulerV2QueryGraphQl(chainId, VAULT_PAGE, { first, skip });
+    const rows = d.eulerVaults ?? [];
+    if (!rows.length) break;
+    for (const r of rows) {
+      const tb = (r.state?.totalBorrows ?? "0").toString();
+      out.push({ asset: r.asset ?? null, borrowCap: r.borrowCap, totalBorrows: tb });
+    }
+    if (rows.length < first) break;
+    skip += first;
+  }
+  return out;
+}
+async function paginateEulerEarnAssets(chainId) {
+  const assets = [];
+  let skip = 0;
+  const first = 1e3;
+  while (true) {
+    const d = await eulerV2QueryGraphQl(
+      chainId,
+      EARN_PAGE,
+      {
+        first,
+        skip
+      }
+    );
+    const rows = d.eulerEarnVaults ?? [];
+    if (!rows.length) break;
+    for (const r of rows) {
+      const a = normAssetAddr(r.asset ?? void 0);
+      if (a) assets.push(a);
+    }
+    if (rows.length < first) break;
+    skip += first;
+  }
+  return assets;
+}
+var eulerV2ChainAssetCache = /* @__PURE__ */ new Map();
+async function fetchEulerV2ChainAssetCache(chainId) {
+  const endpoint = eulerV2GoldskyUrlForChain(chainId);
+  if (!endpoint) {
+    return { nativeWrapped: null, modesByUnderlying: /* @__PURE__ */ new Map() };
+  }
+  const [nativeWrapped, vaultRows, earnAssets] = await Promise.all([
+    resolveEulerWrappedNativeToken(chainId),
+    paginateEulerVaultRows(chainId),
+    paginateEulerEarnAssets(chainId)
+  ]);
+  const modes = /* @__PURE__ */ new Map();
+  const bump = (addr, patch) => {
+    const cur = modes.get(addr) ?? { lend: false, borrow: false, earn: false };
+    modes.set(addr, {
+      lend: cur.lend || !!patch.lend,
+      borrow: cur.borrow || !!patch.borrow,
+      earn: cur.earn || !!patch.earn
+    });
+  };
+  for (const e of earnAssets) bump(e, { earn: true });
+  for (const row of vaultRows) {
+    const a = normAssetAddr(row.asset);
+    if (!a) continue;
+    bump(a, {
+      lend: true,
+      borrow: vaultShowsBorrowTab(row.borrowCap, row.totalBorrows)
+    });
+  }
+  return { nativeWrapped, modesByUnderlying: modes };
+}
+function ensureEulerV2ChainAssetCache(chainId) {
+  const hit = eulerV2ChainAssetCache.get(chainId);
+  if (hit) return hit;
+  const p = fetchEulerV2ChainAssetCache(chainId).catch((e) => {
+    eulerV2ChainAssetCache.delete(chainId);
+    throw e;
+  });
+  eulerV2ChainAssetCache.set(chainId, p);
+  return p;
+}
+
+// src/protocols/evm/euler-v2/loadEulerV2SupportedChainIds.ts
+var cached = null;
+function loadEulerV2SupportedChainIds() {
+  if (cached) return Promise.resolve(cached);
+  cached = new Set(Object.keys(EULER_V2_GOLDSKY_SUBGRAPH_URL_BY_CHAIN_ID).map((k) => Number(k)));
+  return Promise.resolve(cached);
+}
 
 // src/protocols/evm/euler-v2/index.ts
 var EULER_V2_PROTOCOL_ID = "euler-v2";
@@ -9046,20 +9285,6 @@ function getProtocolDiscoverySummary(protocolId) {
   };
 }
 init_support();
-var EULER_V2_SUBGRAPH_CHAIN_IDS = [
-  1,
-  8453,
-  42161,
-  10,
-  137,
-  56,
-  43114,
-  100,
-  59144,
-  146,
-  1923,
-  130
-];
 function advisor(protocolId, tokenFilter, impl) {
   return { protocolId, tokenFilter, ...impl };
 }
@@ -9293,13 +9518,34 @@ var PROTOCOL_SUPPORT_ADVISORS = {
   }),
   "euler-v2": advisor("euler-v2", "subgraph_vaults", {
     async supportedChainIds() {
-      return [...EULER_V2_SUBGRAPH_CHAIN_IDS];
+      const set = await loadEulerV2SupportedChainIds();
+      return [...set].sort((a, b) => a - b);
     },
-    async supportedTokens() {
+    async supportedTokens(chainId) {
+      const cache = await ensureEulerV2ChainAssetCache(chainId);
+      const tokens = [...cache.modesByUnderlying.entries()].map(([address, modes]) => ({
+        address,
+        roles: [
+          ...modes.lend ? ["vault_underlying"] : [],
+          ...modes.borrow ? ["loan"] : [],
+          ...modes.earn ? ["earn"] : []
+        ]
+      }));
       return {
-        tokens: [],
-        notes: "Euler vault/collateral assets vary by chain. Pass vault and asset addresses from Euler app or subgraph."
+        tokens,
+        nativeWrapped: cache.nativeWrapped ?? void 0,
+        notes: "Euler EVK vault underlyings and Earn vault assets from the Goldsky subgraph. Use address as underlyingAddress for ctm_euler_v2_fetch_lend_vaults."
       };
+    },
+    async isTokenSupported(chainId, address) {
+      const cache = await ensureEulerV2ChainAssetCache(chainId);
+      let normalized;
+      try {
+        normalized = viem.getAddress(address).toLowerCase();
+      } catch {
+        return false;
+      }
+      return cache.modesByUnderlying.has(normalized);
     }
   }),
   [MAPLE_PROTOCOL_ID]: advisor(MAPLE_PROTOCOL_ID, "fixed_addresses", {