@continuumdao/ctm-mpc-defi 0.2.1 → 0.2.2

package/dist/protocols/evm/euler-v2/index.cjs

@@ -175,25 +175,25 @@ async function buildEvmMultisignBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
   const feeParams = await continuumNodeSdk.fetchChainFeeParams(rpcUrl, chainId);
   const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
-  const latestBaseFeeWei = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const latestBaseFeeWei = !legacy ? (await publicClient2.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
   const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
   const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
   const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
   const executor = viem.getAddress(executorAddress);
-  const baseNonce = await publicClient.getTransactionCount({ address: executor, blockTag: "pending" });
+  const baseNonce = await publicClient2.getTransactionCount({ address: executor, blockTag: "pending" });
   const legs = [];
   for (let i = 0; i < steps.length; i++) {
     const step = steps[i];
     const currentNonce = baseNonce + i;
     let estimatedGas;
     if (args.estimateGasForStep) {
-      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient, executor });
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient: publicClient2, executor });
     } else {
       try {
-        estimatedGas = await publicClient.estimateGas({
+        estimatedGas = await publicClient2.estimateGas({
           to: step.to,
           data: step.data,
           value: step.value,
@@ -205,7 +205,7 @@ async function buildEvmMultisignBatch(args) {
     }
     let gasLimitI;
     if (args.resolveGasLimit) {
-      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient: publicClient2 });
     } else if (step.routerSwap) {
       gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
     } else {
@@ -215,7 +215,7 @@ async function buildEvmMultisignBatch(args) {
     let feeSnapshot;
     let serialized;
     if (legacy) {
-      let gasPriceWei = await publicClient.getGasPrice();
+      let gasPriceWei = await publicClient2.getGasPrice();
       if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
         gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
       }
@@ -333,14 +333,14 @@ async function fetchEulerVaultUnderlyingMeta(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
-  const assetAddrRaw = await publicClient.readContract({
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const assetAddrRaw = await publicClient2.readContract({
     address: args.evault,
     abi: erc4626AssetAbi,
     functionName: "asset"
   });
   const assetAddr = viem.getAddress(assetAddrRaw);
-  const d = await publicClient.readContract({
+  const d = await publicClient2.readContract({
     address: assetAddr,
     abi: erc20DecimalsAbi,
     functionName: "decimals"
@@ -372,8 +372,8 @@ async function fetchEulerVaultMaxWithdrawWei(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
-  return publicClient.readContract({
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  return publicClient2.readContract({
     address: args.evault,
     abi: erc4626MaxWithdrawAbi,
     functionName: "maxWithdraw",
@@ -410,19 +410,19 @@ async function eulerLendEarnEffectiveMaxWeiBySimulation(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
   let shareBal;
   let vaultCash;
   try {
     ;
     [shareBal, vaultCash] = await Promise.all([
-      publicClient.readContract({
+      publicClient2.readContract({
         address: args.evault,
         abi: eulerVaultSharesCashAbi,
         functionName: "balanceOf",
         args: [args.vaultShareOwner]
       }),
-      publicClient.readContract({
+      publicClient2.readContract({
         address: args.evault,
         abi: eulerVaultSharesCashAbi,
         functionName: "cash"
@@ -434,7 +434,7 @@ async function eulerLendEarnEffectiveMaxWeiBySimulation(args) {
   if (shareBal === 0n) return 0n;
   let assetsOwned;
   try {
-    assetsOwned = await publicClient.readContract({
+    assetsOwned = await publicClient2.readContract({
       address: args.evault,
       abi: eulerVaultSharesCashAbi,
       functionName: "convertToAssets",
@@ -451,7 +451,7 @@ async function eulerLendEarnEffectiveMaxWeiBySimulation(args) {
   while (lo <= hiProbe) {
     const mid = lo + (hiProbe - lo) / 2n;
     const ok = await eulerDirectWithdrawSimulatesOk({
-      publicClient,
+      publicClient: publicClient2,
       evault: args.evault,
       vaultShareOwner: args.vaultShareOwner,
       receiver: args.receiver,
@@ -614,20 +614,20 @@ async function collateralMaxWithdrawBySimulation(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
   let shareBal;
   let assetsOwned;
   let vaultCash;
   try {
     ;
     [shareBal, vaultCash] = await Promise.all([
-      publicClient.readContract({
+      publicClient2.readContract({
         address: args.collateralVault,
         abi: eulerCollateralVaultReadAbi,
         functionName: "balanceOf",
         args: [args.subAccount]
       }),
-      publicClient.readContract({
+      publicClient2.readContract({
         address: args.collateralVault,
         abi: eulerCollateralVaultReadAbi,
         functionName: "cash"
@@ -638,7 +638,7 @@ async function collateralMaxWithdrawBySimulation(args) {
   }
   if (shareBal === 0n) return 0n;
   try {
-    assetsOwned = await publicClient.readContract({
+    assetsOwned = await publicClient2.readContract({
       address: args.collateralVault,
       abi: eulerCollateralVaultReadAbi,
       functionName: "convertToAssets",
@@ -655,7 +655,7 @@ async function collateralMaxWithdrawBySimulation(args) {
   while (lo <= hiProbe) {
     const mid = lo + (hiProbe - lo) / 2n;
     const ok = await evcWithdrawSimulatesOk({
-      publicClient,
+      publicClient: publicClient2,
       evc: args.evc,
       collateralVault: args.collateralVault,
       subAccount: args.subAccount,
@@ -722,8 +722,8 @@ async function buildEvmMultisignBodyEulerV2IsolatedLendDepositBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
-  const dec = await publicClient.readContract({
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const dec = await publicClient2.readContract({
     address: asset,
     abi: erc20AllowanceAbi,
     functionName: "decimals"
@@ -734,7 +734,7 @@ async function buildEvmMultisignBodyEulerV2IsolatedLendDepositBatch(args) {
   if (args.isNativeIn) {
     const dataDeposit = viem.encodeFunctionData({ abi: wethDepositAbi, functionName: "deposit", args: [] });
     steps.push({ kind: "weth_deposit", to: weth, data: dataDeposit, value: amountWei });
-    const wethAllowance = await publicClient.readContract({
+    const wethAllowance = await publicClient2.readContract({
       address: weth,
       abi: erc20AllowanceAbi,
       functionName: "allowance",
@@ -757,7 +757,7 @@ async function buildEvmMultisignBodyEulerV2IsolatedLendDepositBatch(args) {
       steps.push({ kind: "approve", to: weth, data: dataApprove, value: 0n });
     }
   } else {
-    const currentAllowance = await publicClient.readContract({
+    const currentAllowance = await publicClient2.readContract({
       address: asset,
       abi: erc20AllowanceAbi,
       functionName: "allowance",
@@ -917,8 +917,8 @@ async function buildEvmMultisignBodyEulerV2IsolatedBorrowBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
-  const cDecRaw = await publicClient.readContract({
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const cDecRaw = await publicClient2.readContract({
     address: collateralAsset,
     abi: erc20AllowanceAbi2,
     functionName: "decimals"
@@ -926,7 +926,7 @@ async function buildEvmMultisignBodyEulerV2IsolatedBorrowBatch(args) {
   const collateralDecimals = Number(cDecRaw);
   const collateralWei = viem.parseUnits(args.collateralAmountHuman, collateralDecimals);
   if (collateralWei === 0n) throw new Error("Collateral amount is zero after converting with token decimals.");
-  await publicClient.readContract({
+  await publicClient2.readContract({
     address: borrowAsset,
     abi: erc20AllowanceAbi2,
     functionName: "decimals"
@@ -949,7 +949,7 @@ async function buildEvmMultisignBodyEulerV2IsolatedBorrowBatch(args) {
   if (args.isNativeCollateralIn) {
     const dataDeposit = viem.encodeFunctionData({ abi: wethDepositAbi2, functionName: "deposit", args: [] });
     steps.push({ kind: "weth_deposit", to: weth, data: dataDeposit, value: collateralWei });
-    const wethAllowance = await publicClient.readContract({
+    const wethAllowance = await publicClient2.readContract({
       address: weth,
       abi: erc20AllowanceAbi2,
       functionName: "allowance",
@@ -972,7 +972,7 @@ async function buildEvmMultisignBodyEulerV2IsolatedBorrowBatch(args) {
       steps.push({ kind: "approve", to: weth, data: dataApprove, value: 0n });
     }
   } else {
-    const currentAllowance = await publicClient.readContract({
+    const currentAllowance = await publicClient2.readContract({
       address: collateralAsset,
       abi: erc20AllowanceAbi2,
       functionName: "allowance",
@@ -1169,15 +1169,15 @@ async function buildEvmMultisignBodyEulerV2BorrowRepayBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
-  const bDecRaw = await publicClient.readContract({
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const bDecRaw = await publicClient2.readContract({
     address: borrowAsset,
     abi: erc20AllowanceAbi3,
     functionName: "decimals"
   });
   const borrowDecimals = Number(bDecRaw);
   const debtAbi = viem.parseAbi(["function debtOf(address account) view returns (uint256)"]);
-  const owed = await publicClient.readContract({
+  const owed = await publicClient2.readContract({
     address: borrowVault,
     abi: debtAbi,
     functionName: "debtOf",
@@ -1195,7 +1195,7 @@ async function buildEvmMultisignBodyEulerV2BorrowRepayBatch(args) {
   }
   const steps = [];
   const allowanceTarget = repayWei === viem.maxUint256 ? owed : repayWei;
-  const currentAllowance = await publicClient.readContract({
+  const currentAllowance = await publicClient2.readContract({
     address: borrowAsset,
     abi: erc20AllowanceAbi3,
     functionName: "allowance",
@@ -1323,7 +1323,7 @@ async function buildEvmMultisignBodyEulerV2BorrowCollateralDepositBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
   const dec = await fetchEulerVaultAssetDecimals({
     rpcUrl: args.rpcUrl,
     chainId: args.chainId,
@@ -1332,7 +1332,7 @@ async function buildEvmMultisignBodyEulerV2BorrowCollateralDepositBatch(args) {
   const amountWei = viem.parseUnits(args.amountHuman, dec);
   if (amountWei === 0n) throw new Error("Deposit amount is zero after converting with token decimals.");
   const steps = [];
-  const currentAllowance = await publicClient.readContract({
+  const currentAllowance = await publicClient2.readContract({
     address: collateralAsset,
     abi: erc20AllowanceAbi4,
     functionName: "allowance",
@@ -1535,6 +1535,2253 @@ async function buildEvmMultisignBodyEulerV2BorrowCollateralWithdrawBatch(args) {
   });
 }
 
+// src/core/defiProxy.ts
+var aaveGraphqlProxyUrl;
+var eulerGraphqlProxyUrl;
+var coingeckoProxyUrl;
+function getAaveGraphqlProxyUrl() {
+  return aaveGraphqlProxyUrl;
+}
+function getEulerGraphqlProxyUrl() {
+  return eulerGraphqlProxyUrl;
+}
+function getCoingeckoProxyUrl() {
+  return coingeckoProxyUrl;
+}
+async function postJsonViaOptionalProxy(args) {
+  const proxy = args.proxyUrl?.trim();
+  if (proxy) {
+    const r2 = await fetch(proxy, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(args.proxyEnvelope ?? args.body)
+    });
+    if (!r2.ok) {
+      const t = await r2.text().catch(() => "");
+      throw new Error(t ? `Proxy HTTP ${r2.status}: ${t.slice(0, 200)}` : `Proxy HTTP ${r2.status}`);
+    }
+    return await r2.json();
+  }
+  const r = await fetch(args.directUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(args.body)
+  });
+  if (!r.ok) {
+    const t = await r.text().catch(() => "");
+    throw new Error(t ? `HTTP ${r.status}: ${t.slice(0, 200)}` : `HTTP ${r.status}`);
+  }
+  return await r.json();
+}
+
+// src/protocols/evm/aave-v4/api.ts
+var AAVE_V4_GRAPHQL_URL = "https://api.v4.aave.com/graphql";
+async function aaveV4Gql(query, variables) {
+  const body = { query, variables: variables ?? {} };
+  const j = await postJsonViaOptionalProxy({
+    directUrl: AAVE_V4_GRAPHQL_URL,
+    body,
+    proxyUrl: getAaveGraphqlProxyUrl(),
+    proxyEnvelope: body
+  });
+  if (j.errors?.length) {
+    const msg = j.errors.map((e) => e.message ?? "Unknown").join("; ");
+    throw new Error(msg);
+  }
+  if (j.data == null) {
+    throw new Error("Aave V4 API: empty response");
+  }
+  return j.data;
+}
+async function fetchAaveV4Chains() {
+  const d = await aaveV4Gql(`
+    query C($c: ChainsRequest!) { chains(request: $c) { chainId name nativeWrappedToken } }
+  `, { c: { query: { filter: "ALL" } } });
+  return d.chains ?? [];
+}
+async function fetchAaveV4NativeWrappedToken(chainId) {
+  const all = await fetchAaveV4Chains();
+  const c = all.find((x) => x.chainId === chainId);
+  const t = (c?.nativeWrappedToken ?? "").trim();
+  if (t && viem.isAddress(t)) return viem.getAddress(t);
+  return null;
+}
+var EULER_EVAULT_CAP_UNLIMITED_WEI = (1n << 256n) - 1n;
+var UINT256_MAX = EULER_EVAULT_CAP_UNLIMITED_WEI;
+var EULER_EVAULT_SUPPLY_CAP_UNLIMITED_WEI = EULER_EVAULT_CAP_UNLIMITED_WEI;
+var EULER_V2_PREFER_ON_CHAIN_LEND_METRICS = false;
+var eulerVaultLendAbi = 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;
+}
+var resolveEulerAmountCapToSupplyWei = resolveEulerAmountCapToWei;
+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;
+  }
+}
+function eulerVaultLendMetricsFromIndexerVaultState(args) {
+  let rawSupplyCap16 = 0;
+  let rawBorrowCap16 = 0;
+  try {
+    rawSupplyCap16 = Number(BigInt((args.supplyCapRaw ?? "").trim() || "0") & 0xffffn);
+  } catch {
+    rawSupplyCap16 = 0;
+  }
+  try {
+    rawBorrowCap16 = Number(BigInt((args.borrowCapRaw ?? "").trim() || "0") & 0xffffn);
+  } catch {
+    rawBorrowCap16 = 0;
+  }
+  return {
+    rawSupplyCap16,
+    rawBorrowCap16,
+    supplyCapWei: eulerSubgraphVaultCapToUnderlyingWei(args.supplyCapRaw),
+    borrowCapWei: eulerSubgraphVaultCapToUnderlyingWei(args.borrowCapRaw),
+    cashWei: args.cashWei,
+    totalBorrowsWei: args.totalBorrowsWei,
+    totalAssetsWei: args.totalAssetsWei
+  };
+}
+function formatEulerResolvedCapOrCashForUi(wei, decimals, symbolSuffix) {
+  if (wei >= EULER_EVAULT_CAP_UNLIMITED_WEI - 3n) return "Unlimited";
+  if (wei === 0n) return symbolSuffix ? `0 ${symbolSuffix}` : "0";
+  try {
+    const s = viem.formatUnits(wei, decimals);
+    const n = Number(s);
+    if (Number.isFinite(n) && Math.abs(n) >= 1e9) return `${n.toExponential(2)}${symbolSuffix ? ` ${symbolSuffix}` : ""}`;
+    return symbolSuffix ? `${s} ${symbolSuffix}` : s;
+  } catch {
+    return wei.toString();
+  }
+}
+function eulerVaultMaxNewSupplyWei(metrics) {
+  const { supplyCapWei, totalAssetsWei } = metrics;
+  if (supplyCapWei === 0n) return 0n;
+  if (supplyCapWei >= EULER_EVAULT_CAP_UNLIMITED_WEI - 3n) return EULER_EVAULT_CAP_UNLIMITED_WEI;
+  if (totalAssetsWei >= supplyCapWei) return 0n;
+  return supplyCapWei - totalAssetsWei;
+}
+function eulerVaultMaxNewBorrowWei(metrics) {
+  const { cashWei, borrowCapWei, totalBorrowsWei } = metrics;
+  if (borrowCapWei === 0n) return 0n;
+  if (borrowCapWei >= EULER_EVAULT_CAP_UNLIMITED_WEI - 3n) return cashWei;
+  const capLeft = borrowCapWei > totalBorrowsWei ? borrowCapWei - totalBorrowsWei : 0n;
+  return cashWei < capLeft ? cashWei : capLeft;
+}
+async function fetchEulerVaultOnChainLendMetrics(args) {
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "EulerVaultRead",
+    nativeCurrency: { decimals: 18, name: "x", symbol: "x" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const client = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const addr = viem.getAddress(args.evault);
+  const [[supplyRaw, borrowRaw], cashWei, totalBorrowsWei, totalAssetsWei] = await Promise.all([
+    client.readContract({
+      address: addr,
+      abi: eulerVaultLendAbi,
+      functionName: "caps"
+    }),
+    client.readContract({
+      address: addr,
+      abi: eulerVaultLendAbi,
+      functionName: "cash"
+    }),
+    client.readContract({
+      address: addr,
+      abi: eulerVaultLendAbi,
+      functionName: "totalBorrows"
+    }),
+    client.readContract({
+      address: addr,
+      abi: eulerVaultLendAbi,
+      functionName: "totalAssets"
+    })
+  ]);
+  const rs = Number(supplyRaw);
+  const rb = Number(borrowRaw);
+  return {
+    rawSupplyCap16: rs,
+    rawBorrowCap16: rb,
+    supplyCapWei: resolveEulerAmountCapToWei(rs),
+    borrowCapWei: resolveEulerAmountCapToWei(rb),
+    cashWei,
+    totalBorrowsWei,
+    totalAssetsWei
+  };
+}
+async function fetchEulerVaultOnChainLendMetricsForVaults(args) {
+  const rpc = (args.rpcUrl ?? "").trim();
+  const out = /* @__PURE__ */ new Map();
+  if (!rpc || !args.vaults.length) return out;
+  const concurrency = 8;
+  let idx = 0;
+  const list = [...args.vaults];
+  async function worker() {
+    while (idx < list.length) {
+      const i = idx++;
+      const row = list[i];
+      try {
+        const ev = viem.getAddress(row.evault.trim());
+        const data = await fetchEulerVaultOnChainLendMetrics({
+          rpcUrl: rpc,
+          chainId: args.chainId,
+          evault: ev
+        });
+        out.set(row.key, { ok: true, data });
+      } catch (e) {
+        out.set(row.key, {
+          ok: false,
+          message: e instanceof Error ? e.message : "On-chain read failed"
+        });
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, list.length) }, () => worker()));
+  return out;
+}
+
+// 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 eulerWrappedGasTokenAliasesLower(chainId) {
+  const s = /* @__PURE__ */ new Set();
+  const fb = WRAPPED_NATIVE_FALLBACK[chainId];
+  if (fb && viem.isAddress(fb)) {
+    try {
+      s.add(viem.getAddress(fb).toLowerCase());
+    } catch {
+    }
+  }
+  try {
+    const aave = await fetchAaveV4NativeWrappedToken(chainId);
+    if (aave && viem.isAddress(aave)) s.add(viem.getAddress(aave).toLowerCase());
+  } catch {
+  }
+  return s;
+}
+function eulerV2KeyForNodeAssetRow(args) {
+  const raw = (args.contractAddress ?? "").trim();
+  try {
+    const a = viem.getAddress(raw);
+    if (a.toLowerCase() === "0x0000000000000000000000000000000000000000" && args.nativeWrapped) {
+      return viem.getAddress(args.nativeWrapped.trim()).toLowerCase();
+    }
+    return a.toLowerCase();
+  } catch {
+    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);
+}
+var EULER_TRACKING_DEPOSITS_GQL = `
+query EulerTrackingDeposits($id: Bytes!) {
+  trackingActiveAccount(id: $id) {
+    deposits
+  }
+}`;
+async function fetchEulerV2TrackingDepositEntries(args) {
+  if (!eulerV2GoldskyUrlForChain(args.chainId)) return [];
+  const id = args.mainAddress.toLowerCase();
+  const data = await eulerV2QueryGraphQl(
+    args.chainId,
+    EULER_TRACKING_DEPOSITS_GQL,
+    { id }
+  );
+  const raw = data.trackingActiveAccount?.deposits ?? [];
+  return raw.filter((x) => typeof x === "string" && x.trim().length > 0);
+}
+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(endpoint) {
+  const out = [];
+  let skip = 0;
+  const first = 1e3;
+  while (true) {
+    const d = await eulerSubgraphGql(endpoint, 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(endpoint) {
+  const assets = [];
+  let skip = 0;
+  const first = 1e3;
+  while (true) {
+    const d = await eulerSubgraphGql(endpoint, 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(endpoint),
+    paginateEulerEarnAssets(endpoint)
+  ]);
+  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);
+  eulerV2ChainAssetCache.set(chainId, p);
+  return p;
+}
+var LABELS_PRODUCTS_URL = (chainId) => `https://raw.githubusercontent.com/euler-xyz/euler-labels/master/${chainId}/products.json`;
+function normAddrKey(raw) {
+  const s = (raw ?? "").trim();
+  if (!s) return null;
+  try {
+    return viem.getAddress(s.startsWith("0x") ? s : `0x${s}`).toLowerCase();
+  } catch {
+    return null;
+  }
+}
+function eulerLabelsAppendUnderlyingIfDistinct(base, underlyingSymbol) {
+  const b = (base ?? "").trim();
+  const sym = (underlyingSymbol ?? "").trim();
+  if (!b) return "\u2014";
+  if (!sym) return b;
+  if (b.toLowerCase().includes(sym.toLowerCase())) return b;
+  return `${b} ${sym}`;
+}
+var labelMapCache = /* @__PURE__ */ new Map();
+function fetchEulerLabelsVaultNameMap(chainId) {
+  let hit = labelMapCache.get(chainId);
+  if (!hit) {
+    hit = (async () => {
+      const m = /* @__PURE__ */ new Map();
+      try {
+        const res = await fetch(LABELS_PRODUCTS_URL(chainId), { cache: "force-cache" });
+        if (!res.ok) return m;
+        const j = await res.json();
+        if (!j || typeof j !== "object") return m;
+        for (const prod of Object.values(j)) {
+          const productName = (prod?.name ?? "").trim();
+          const vaults = prod?.vaults ?? [];
+          const overrides = prod?.vaultOverrides ?? {};
+          const overrideNameByVault = /* @__PURE__ */ new Map();
+          for (const [addr, ov] of Object.entries(overrides)) {
+            const k = normAddrKey(addr);
+            const n = (ov?.name ?? "").trim();
+            if (k && n) overrideNameByVault.set(k, n);
+          }
+          for (const vAddr of vaults) {
+            const k = normAddrKey(vAddr);
+            if (!k) continue;
+            const overrideName = overrideNameByVault.get(k);
+            const base = overrideName || productName;
+            if (!base) continue;
+            m.set(k, base);
+          }
+        }
+      } catch {
+      }
+      return m;
+    })();
+    labelMapCache.set(chainId, hit);
+  }
+  return hit;
+}
+function eulerLabelsLookupLabelForVault(labelMap, evaultAddress) {
+  const k = normAddrKey(evaultAddress);
+  if (!k) return void 0;
+  const v = labelMap.get(k);
+  return typeof v === "string" && v.trim() ? v.trim() : void 0;
+}
+
+// src/protocols/evm/euler-v2/eulerV2LendMarkets.ts
+var erc20StringMetaAbi = viem.parseAbi([
+  "function name() view returns (string)",
+  "function symbol() view returns (string)"
+]);
+var LEND_VAULT_PAGE = `
+query EulerLendVaults($first: Int!, $skip: Int!, $asset: Bytes!) {
+  eulerVaults(
+    first: $first
+    skip: $skip
+    where: { asset: $asset }
+    orderBy: state__supplyApy
+    orderDirection: desc
+  ) {
+    id
+    evc
+    evault
+    name
+    symbol
+    asset
+    decimals
+    supplyCap
+    borrowCap
+    interestFee
+    perspectives
+    collaterals
+    oracle
+    unitOfAccount
+    governonAdmin
+    state {
+      cash
+      totalBorrows
+      totalShares
+      supplyApy
+      borrowApy
+      timestamp
+    }
+  }
+}
+`;
+var COLLATERAL_META = `
+query EulerCollateralVaults($first: Int!, $ids: [Bytes!]!) {
+  eulerVaults(first: $first, where: { id_in: $ids }) {
+    id
+    evault
+    name
+    symbol
+    asset
+    decimals
+    state {
+      supplyApy
+    }
+  }
+}
+`;
+function normId(raw) {
+  const s = (raw ?? "").trim().toLowerCase();
+  return s.length ? s : null;
+}
+function normAssetLower(raw) {
+  const s = (raw ?? "").trim();
+  if (!s || !viem.isAddress(s)) return null;
+  return viem.getAddress(s).toLowerCase();
+}
+function checksumHex(raw) {
+  const s = (raw ?? "").trim();
+  if (!s || !viem.isAddress(s)) return null;
+  try {
+    return viem.getAddress(s);
+  } catch {
+    return null;
+  }
+}
+function eulerMetaPublicClient(chainId, rpcUrl) {
+  const chain = viem.defineChain({
+    id: chainId,
+    name: "EulerCollateralMeta",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return viem.createPublicClient({ chain, transport: viem.http(rpcUrl) });
+}
+async function readErc20StringMeta(client, addrLower) {
+  try {
+    const addr = viem.getAddress(addrLower);
+    const [nameResult, symbolResult] = await Promise.all([
+      client.readContract({ address: addr, abi: erc20StringMetaAbi, functionName: "name" }),
+      client.readContract({ address: addr, abi: erc20StringMetaAbi, functionName: "symbol" })
+    ]);
+    return {
+      name: typeof nameResult === "string" ? nameResult.trim() : String(nameResult ?? "").trim(),
+      symbol: typeof symbolResult === "string" ? symbolResult.trim() : String(symbolResult ?? "").trim()
+    };
+  } catch {
+    return null;
+  }
+}
+async function resolveUnderlyingTokenLabels(args) {
+  const out = /* @__PURE__ */ new Map();
+  const uniq = [...new Set(args.assetAddresses.map((a) => normAssetLower(a)).filter(Boolean))];
+  const missingFromNode = [];
+  const node = args.nodeErc20ByAddress;
+  for (const low of uniq) {
+    const hit = node?.get(low);
+    if (hit && ((hit.symbol ?? "").trim() || (hit.name ?? "").trim())) {
+      out.set(low, { name: (hit.name ?? "").trim(), symbol: (hit.symbol ?? "").trim() });
+    } else {
+      missingFromNode.push(low);
+    }
+  }
+  const rpc = (args.rpcUrl ?? "").trim();
+  if (!missingFromNode.length || !rpc) return out;
+  const client = eulerMetaPublicClient(args.chainId, rpc);
+  const batchSize = 10;
+  for (let i = 0; i < missingFromNode.length; i += batchSize) {
+    const chunk = missingFromNode.slice(i, i + batchSize);
+    const settled = await Promise.all(chunk.map((low) => readErc20StringMeta(client, low)));
+    chunk.forEach((low, j) => {
+      const m = settled[j];
+      if (m && (m.symbol || m.name)) out.set(low, m);
+    });
+  }
+  return out;
+}
+function formatEulerRayApyPercent(apyRay) {
+  if (apyRay === 0n) return "0.00%";
+  const r = Number(viem.formatUnits(apyRay, 27));
+  if (!Number.isFinite(r)) return "\u2014";
+  const pct = r * 100;
+  if (pct >= 100) return `${pct.toFixed(1)}%`;
+  if (pct >= 10) return `${pct.toFixed(2)}%`;
+  return `${pct.toFixed(2)}%`;
+}
+var formatEulerRaySupplyApyPercent = formatEulerRayApyPercent;
+function formatUnderlyingAmount(raw, decimals) {
+  try {
+    const v = BigInt((raw ?? "").trim() || "0");
+    const s = viem.formatUnits(v, decimals);
+    const n = Number(s);
+    if (!Number.isFinite(n)) return s;
+    if (n === 0) return "0";
+    const abs = Math.abs(n);
+    if (abs >= 1e9) return n.toExponential(2);
+    if (abs >= 1e6) return n.toLocaleString(void 0, { maximumFractionDigits: 0 });
+    if (abs >= 1) return n.toLocaleString(void 0, { maximumFractionDigits: 2 });
+    return n.toLocaleString(void 0, { maximumFractionDigits: 6 });
+  } catch {
+    return "\u2014";
+  }
+}
+function formatEulerVaultCapDisplay(raw, decimals) {
+  try {
+    const wei = eulerSubgraphVaultCapToUnderlyingWei(raw);
+    if (wei >= EULER_EVAULT_CAP_UNLIMITED_WEI - 3n) return "Unlimited";
+    if (wei === 0n) return "0";
+    return formatUnderlyingAmount(wei.toString(), decimals);
+  } catch {
+    return "\u2014";
+  }
+}
+function formatEulerInterestFee(raw) {
+  try {
+    const fee = BigInt((raw ?? "").trim() || "0");
+    if (fee === 0n) return "0%";
+    const pct = Number(fee) / 100;
+    return `${pct.toFixed(2)}%`;
+  } catch {
+    return "\u2014";
+  }
+}
+function formatEulerIndexedTimestamp(raw) {
+  try {
+    const sec = BigInt((raw ?? "").trim() || "0");
+    const n = Number(sec);
+    if (!Number.isFinite(n) || n <= 0) return "\u2014";
+    return new Date(n * 1e3).toLocaleString(void 0, {
+      dateStyle: "medium",
+      timeStyle: "short"
+    });
+  } catch {
+    return "\u2014";
+  }
+}
+function utilizationPercentLabel(cash, borrows) {
+  const denom = cash + borrows;
+  if (denom === 0n) return "0.00%";
+  const scaled = borrows * 1000000n / denom;
+  const pct = Number(scaled) / 1e4;
+  return `${pct.toFixed(2)}%`;
+}
+function collateralLabelFromVault(name, symbol, id) {
+  const n = (name ?? "").trim();
+  const sym = (symbol ?? "").trim();
+  if (n && sym && n.toLowerCase() !== sym.toLowerCase()) return `${n} (${sym})`;
+  if (n) return n;
+  if (sym) return sym;
+  return id.slice(0, 10);
+}
+function marketLabelFromSubgraphRow(r, evaultChecksum) {
+  const n = (r.name ?? "").trim();
+  if (n) return n;
+  const sym = (r.symbol ?? "").trim();
+  if (sym) return sym;
+  const addr = (evaultChecksum ?? "").trim();
+  if (addr.startsWith("0x") && addr.length >= 14) return `${addr.slice(0, 8)}\u2026${addr.slice(-6)}`;
+  return addr || "\u2014";
+}
+function normalizePerspectives(raw) {
+  const out = [];
+  for (const p of raw ?? []) {
+    const s = (p ?? "").trim();
+    if (s) out.push(s);
+  }
+  return out;
+}
+function vaultSupplyBorrowApyRays(r) {
+  let supplyApyRay = 0n;
+  let borrowApyRay = 0n;
+  try {
+    supplyApyRay = BigInt((r.state?.supplyApy ?? "0").toString().trim() || "0");
+  } catch {
+    supplyApyRay = 0n;
+  }
+  try {
+    borrowApyRay = BigInt((r.state?.borrowApy ?? "0").toString().trim() || "0");
+  } catch {
+    borrowApyRay = 0n;
+  }
+  return { supplyApyRay, borrowApyRay };
+}
+function vaultCashAndBorrows(r) {
+  let cash = 0n;
+  let borrows = 0n;
+  try {
+    cash = BigInt((r.state?.cash ?? "0").toString().trim() || "0");
+  } catch {
+    cash = 0n;
+  }
+  try {
+    borrows = BigInt((r.state?.totalBorrows ?? "0").toString().trim() || "0");
+  } catch {
+    borrows = 0n;
+  }
+  return { cash, borrows };
+}
+async function paginateLendVaultRows(chainId, assetLower) {
+  const out = [];
+  let skip = 0;
+  const first = 500;
+  while (true) {
+    const d = await eulerV2QueryGraphQl(chainId, LEND_VAULT_PAGE, {
+      first,
+      skip,
+      asset: assetLower
+    });
+    const rows = d.eulerVaults ?? [];
+    if (!rows.length) break;
+    out.push(...rows);
+    if (rows.length < first) break;
+    skip += first;
+  }
+  return out;
+}
+async function fetchCollateralVaultMeta(chainId, collateralIds) {
+  const map = /* @__PURE__ */ new Map();
+  const uniq = [...new Set(collateralIds.map((x) => x.toLowerCase()))].filter(Boolean);
+  const chunkSize = 400;
+  for (let i = 0; i < uniq.length; i += chunkSize) {
+    const chunk = uniq.slice(i, i + chunkSize);
+    const d = await eulerV2QueryGraphQl(chainId, COLLATERAL_META, { first: chunk.length, ids: chunk });
+    for (const r of d.eulerVaults ?? []) {
+      const id = normId(r.id ?? void 0);
+      if (!id) continue;
+      let dec = 18;
+      try {
+        dec = Number.parseInt((r.decimals ?? "18").trim(), 10);
+        if (!Number.isFinite(dec) || dec < 0 || dec > 36) dec = 18;
+      } catch {
+        dec = 18;
+      }
+      let supplyApyRay = 0n;
+      try {
+        supplyApyRay = BigInt((r.state?.supplyApy ?? "0").toString().trim() || "0");
+      } catch {
+        supplyApyRay = 0n;
+      }
+      map.set(id, {
+        name: (r.name ?? "").trim(),
+        symbol: (r.symbol ?? "").trim(),
+        assetLower: normAssetLower(r.asset ?? void 0),
+        evaultChecksum: checksumHex(r.evault ?? void 0) ?? checksumHex(r.id ?? void 0),
+        decimals: dec,
+        supplyApyRay
+      });
+    }
+  }
+  return map;
+}
+function flattenEulerV2BorrowCollateralRows(markets) {
+  const out = [];
+  for (const m of markets) {
+    if (m.borrowApyRay === 0n) continue;
+    const borrowNum = Number.parseFloat(m.borrowApyPercentLabel.replace(/%/g, "").trim()) || 0;
+    for (const c of m.collateralTokens) {
+      if (!c.collateralEvaultAddress) continue;
+      const supplyNum = Number.parseFloat(c.collateralSupplyApyPercentLabel.replace(/%/g, "").trim()) || 0;
+      const net = supplyNum - borrowNum;
+      const netLabel = `${net.toFixed(2)}%`;
+      out.push({
+        pairKey: `${m.vaultId}:${c.vaultId}`,
+        borrowVaultId: m.vaultId,
+        borrowEvaultAddress: m.evaultAddress,
+        borrowMarketName: m.marketName,
+        borrowDecimals: m.decimals,
+        borrowApyPercentLabel: m.borrowApyPercentLabel,
+        borrowCash: m.cash,
+        borrowTotalBorrows: m.totalBorrows,
+        netApyPercentLabel: netLabel,
+        utilizationPercentLabel: m.utilizationPercentLabel,
+        availableLiquidityFormatted: m.availableLiquidityFormatted,
+        evcAddress: m.evcAddress,
+        oracleAddress: m.oracleAddress,
+        unitOfAccountAddress: m.unitOfAccountAddress,
+        borrowAssetAddressLower: m.borrowAssetAddressLower,
+        governonAdminChecksum: m.governonAdminChecksum,
+        collateralVaultId: c.vaultId,
+        collateralEvaultAddress: c.collateralEvaultAddress,
+        collateralSymbol: c.underlyingSymbol,
+        collateralName: c.underlyingName,
+        collateralVaultLabel: c.vaultMarketLabel,
+        collateralDecimals: c.collateralDecimals,
+        collateralAssetAddressLower: c.collateralAssetAddressLower,
+        collateralSupplyApyPercentLabel: c.collateralSupplyApyPercentLabel,
+        borrowIndexerLendMetrics: m.indexerLendMetrics
+      });
+    }
+  }
+  return out;
+}
+async function fetchEulerV2IsolatedLendMarketsForRowAsset(args) {
+  const cache = await ensureEulerV2ChainAssetCache(args.chainId);
+  const underlying = eulerV2KeyForNodeAssetRow({
+    contractAddress: args.contractAddress,
+    nativeWrapped: cache.nativeWrapped
+  });
+  if (!underlying) return [];
+  const [gqlRows, labelMap] = await Promise.all([
+    paginateLendVaultRows(args.chainId, underlying),
+    fetchEulerLabelsVaultNameMap(args.chainId)
+  ]);
+  const eligibleRows = gqlRows.filter((r) => {
+    const { supplyApyRay, borrowApyRay } = vaultSupplyBorrowApyRays(r);
+    if (supplyApyRay === 0n && borrowApyRay === 0n) return false;
+    const { cash, borrows } = vaultCashAndBorrows(r);
+    return cash + borrows !== 0n;
+  });
+  if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+    let matched = 0;
+    for (const r of eligibleRows) {
+      const evRaw = checksumHex(r.evault ?? void 0) ?? checksumHex(r.id ?? void 0);
+      if (!evRaw) continue;
+      if (eulerLabelsLookupLabelForVault(labelMap, evRaw)) matched += 1;
+    }
+    console.debug("[Euler labels]", {
+      chainId: args.chainId,
+      matchedEligibleVaults: matched,
+      eligibleVaults: eligibleRows.length,
+      labelMapEntries: labelMap.size
+    });
+  }
+  const collateralIds = [];
+  for (const r of eligibleRows) {
+    for (const c of r.collaterals ?? []) {
+      const id = normId(c ?? void 0);
+      if (id) collateralIds.push(id);
+    }
+  }
+  const collateralMeta = await fetchCollateralVaultMeta(args.chainId, collateralIds);
+  const underlyingAssetAddrs = [];
+  for (const m of collateralMeta.values()) {
+    if (m.assetLower) underlyingAssetAddrs.push(m.assetLower);
+  }
+  const underlyingLabels = await resolveUnderlyingTokenLabels({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    nodeErc20ByAddress: args.nodeErc20ByAddress,
+    assetAddresses: underlyingAssetAddrs
+  });
+  const rows = [];
+  for (const r of eligibleRows) {
+    const vaultId = normId(r.id ?? void 0);
+    if (!vaultId) continue;
+    const evaultAddress = checksumHex(r.evault ?? void 0) ?? checksumHex(r.id ?? void 0) ?? vaultId;
+    const subgraphTitle = marketLabelFromSubgraphRow(r, evaultAddress);
+    const labelBase = eulerLabelsLookupLabelForVault(labelMap, evaultAddress);
+    const assetSym = (args.suppliedAssetSymbol ?? "").trim();
+    const marketName = labelBase ? eulerLabelsAppendUnderlyingIfDistinct(labelBase, assetSym) : subgraphTitle;
+    let dec = 18;
+    try {
+      dec = Number.parseInt((r.decimals ?? "18").trim(), 10);
+      if (!Number.isFinite(dec) || dec < 0 || dec > 36) dec = 18;
+    } catch {
+      dec = 18;
+    }
+    const { cash, borrows } = vaultCashAndBorrows(r);
+    const { supplyApyRay, borrowApyRay } = vaultSupplyBorrowApyRays(r);
+    const total = cash + borrows;
+    const cIds = [...new Set((r.collaterals ?? []).map((x) => normId(x ?? void 0)).filter(Boolean))];
+    const collateralTokens = cIds.map((cid) => {
+      const vm = collateralMeta.get(cid);
+      const vaultMarketLabel = vm ? collateralLabelFromVault(vm.name, vm.symbol, cid) : cid.slice(0, 10);
+      const assetLow = vm?.assetLower ?? null;
+      const und = assetLow ? underlyingLabels.get(assetLow) : void 0;
+      const sym = (und?.symbol ?? "").trim();
+      const nam = (und?.name ?? "").trim();
+      let underlyingSymbol;
+      let underlyingName;
+      if (sym || nam) {
+        underlyingSymbol = sym || nam;
+        underlyingName = sym && nam && nam.toLowerCase() !== sym.toLowerCase() ? nam : null;
+      } else {
+        underlyingSymbol = vaultMarketLabel;
+        underlyingName = null;
+      }
+      const collSupplyRay = vm?.supplyApyRay ?? 0n;
+      return {
+        vaultId: cid,
+        collateralEvaultAddress: vm?.evaultChecksum ?? null,
+        collateralDecimals: vm?.decimals ?? 18,
+        collateralAssetAddressLower: assetLow,
+        collateralSupplyApyPercentLabel: formatEulerRayApyPercent(collSupplyRay),
+        underlyingSymbol,
+        underlyingName,
+        vaultMarketLabel
+      };
+    });
+    const indexerLendMetrics = eulerVaultLendMetricsFromIndexerVaultState({
+      supplyCapRaw: r.supplyCap,
+      borrowCapRaw: r.borrowCap,
+      cashWei: cash,
+      totalBorrowsWei: borrows,
+      totalAssetsWei: total
+    });
+    rows.push({
+      vaultId,
+      evaultAddress,
+      marketName,
+      decimals: dec,
+      cash,
+      totalBorrows: borrows,
+      supplyApyPercentLabel: formatEulerRayApyPercent(supplyApyRay),
+      borrowApyPercentLabel: formatEulerRayApyPercent(borrowApyRay),
+      totalSupplyFormatted: formatUnderlyingAmount(total.toString(), dec),
+      availableLiquidityFormatted: formatUnderlyingAmount(cash.toString(), dec),
+      utilizationPercentLabel: utilizationPercentLabel(cash, borrows),
+      supplyCapFormatted: formatEulerVaultCapDisplay(r.supplyCap, dec),
+      borrowCapFormatted: formatEulerVaultCapDisplay(r.borrowCap, dec),
+      interestFeeLabel: formatEulerInterestFee(r.interestFee),
+      stateIndexedDisplay: formatEulerIndexedTimestamp(r.state?.timestamp),
+      perspectives: normalizePerspectives(r.perspectives),
+      evcAddress: checksumHex(r.evc ?? void 0),
+      oracleAddress: checksumHex(r.oracle ?? void 0),
+      unitOfAccountAddress: checksumHex(r.unitOfAccount ?? void 0),
+      borrowAssetAddressLower: normAssetLower(r.asset ?? void 0),
+      governonAdminChecksum: checksumHex(r.governonAdmin ?? void 0),
+      borrowApyRay,
+      indexerLendMetrics,
+      collateralTokens
+    });
+  }
+  return rows;
+}
+var UINT256_MAX2 = (1n << 256n) - 1n;
+var EARN_STRATEGY_ALLOC_CAP_SUBGRAPH_UNBOUNDED = 87112285931760246646623899502532662132735n;
+var EARN_VAULTS_QUERY = `
+query EulerEarnForAsset($asset: Bytes!, $ids: [Bytes!]!) {
+  eulerEarnVaults(first: 500, where: { asset: $asset, id_in: $ids }) {
+    id
+    name
+    curator
+    performanceFee
+    totalAssets
+    totalAllocated
+    asset
+    strategies(first: 200) {
+      strategy
+      allocatedAssets
+      availableAssets
+      currentAllocationCap
+    }
+  }
+}
+`;
+var STRATEGY_VAULT_APY = `
+query EulerStrategyVaults($ids: [Bytes!]!) {
+  eulerVaults(first: 500, where: { id_in: $ids }) {
+    id
+    asset
+    symbol
+    state {
+      supplyApy
+    }
+  }
+}
+`;
+function normLowerId(raw) {
+  const s = (raw ?? "").trim().toLowerCase();
+  if (!s.startsWith("0x") || s.length < 4) return null;
+  return s;
+}
+function big(raw) {
+  try {
+    return BigInt((raw ?? "0").toString().trim() || "0");
+  } catch {
+    return 0n;
+  }
+}
+async function fetchEulerLabelsEarnVaultAllowlist(chainId) {
+  const url = `https://raw.githubusercontent.com/euler-xyz/euler-labels/master/${chainId}/earn-vaults.json`;
+  const r = await fetch(url, { cache: "no-store" });
+  if (!r.ok) return /* @__PURE__ */ new Set();
+  let j;
+  try {
+    j = await r.json();
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  const out = /* @__PURE__ */ new Set();
+  if (!Array.isArray(j)) return out;
+  for (const entry of j) {
+    if (typeof entry === "string") {
+      const lo = normLowerId(entry);
+      if (lo) out.add(lo);
+      continue;
+    }
+    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+      const o = entry;
+      if (o.deprecated === true) continue;
+      const addr = typeof o.address === "string" ? o.address : typeof o.id === "string" ? o.id : null;
+      const lo = normLowerId(addr);
+      if (lo) out.add(lo);
+    }
+  }
+  return out;
+}
+async function fetchEulerLabelsEntityNameByAddress(chainId) {
+  const url = `https://raw.githubusercontent.com/euler-xyz/euler-labels/master/${chainId}/entities.json`;
+  const r = await fetch(url, { cache: "no-store" });
+  const m = /* @__PURE__ */ new Map();
+  if (!r.ok) return m;
+  let j;
+  try {
+    j = await r.json();
+  } catch {
+    return m;
+  }
+  if (!j || typeof j !== "object") return m;
+  for (const ent of Object.values(j)) {
+    if (!ent || typeof ent !== "object") continue;
+    const name = ent.name;
+    const groupName = typeof name === "string" && name.trim() ? name.trim() : null;
+    if (!groupName) continue;
+    const addrs = ent.addresses;
+    if (!addrs || typeof addrs !== "object") continue;
+    for (const k of Object.keys(addrs)) {
+      const lo = normLowerId(k);
+      if (lo) m.set(lo, groupName);
+    }
+  }
+  return m;
+}
+function formatPerformanceFeePercent(feeWad) {
+  if (feeWad === 0n) return "0%";
+  const x = Number(viem.formatUnits(feeWad, 18));
+  if (!Number.isFinite(x)) return "\u2014";
+  const pct = x * 100;
+  if (pct >= 10) return `${pct.toFixed(1)}%`;
+  if (pct >= 1) return `${pct.toFixed(2)}%`;
+  return `${pct.toFixed(2)}%`;
+}
+function isMaxUintCap(cap) {
+  return cap >= UINT256_MAX2 - 3n;
+}
+function isUnboundedEarnStrategyAllocationCap(cap) {
+  return isMaxUintCap(cap) || cap === EARN_STRATEGY_ALLOC_CAP_SUBGRAPH_UNBOUNDED;
+}
+async function fetchEulerV2EarnOfferingsForRowAsset(args) {
+  const { chainId, underlyingDecimals } = args;
+  const cache = await ensureEulerV2ChainAssetCache(chainId);
+  const key = eulerV2KeyForNodeAssetRow({
+    contractAddress: args.contractAddress,
+    nativeWrapped: cache.nativeWrapped
+  });
+  if (!key) return [];
+  const [allowlist, entityByAddr] = await Promise.all([
+    fetchEulerLabelsEarnVaultAllowlist(chainId),
+    fetchEulerLabelsEntityNameByAddress(chainId)
+  ]);
+  if (!allowlist.size) return [];
+  const assetBytes = key;
+  const ids = [...allowlist];
+  const data = await eulerV2QueryGraphQl(chainId, EARN_VAULTS_QUERY, {
+    asset: assetBytes,
+    ids
+  });
+  const rawRows = data.eulerEarnVaults ?? [];
+  const strategyIds = /* @__PURE__ */ new Set();
+  for (const v of rawRows) {
+    for (const s of v.strategies ?? []) {
+      const sid = normLowerId(s.strategy ?? void 0);
+      if (sid) strategyIds.add(sid);
+    }
+  }
+  const apyByVault = /* @__PURE__ */ new Map();
+  const sidList = [...strategyIds];
+  const batch = 200;
+  for (let i = 0; i < sidList.length; i += batch) {
+    const chunk = sidList.slice(i, i + batch);
+    const d2 = await eulerV2QueryGraphQl(chainId, STRATEGY_VAULT_APY, {
+      ids: chunk
+    });
+    for (const row of d2.eulerVaults ?? []) {
+      const id = normLowerId(row.id ?? void 0);
+      if (!id) continue;
+      const ray = big(row.state?.supplyApy ?? "0");
+      const sym = (row.symbol ?? "").trim() || "\u2014";
+      const al = normLowerId(row.asset ?? void 0);
+      apyByVault.set(id, { apyRay: ray, symbol: sym, assetLower: al });
+    }
+  }
+  const dec = Math.max(0, Math.min(36, Math.floor(underlyingDecimals)));
+  const tic = (args.suppliedAssetSymbol ?? "").trim();
+  const out = [];
+  for (const v of rawRows) {
+    const vid = normLowerId(v.id ?? void 0);
+    if (!vid || !allowlist.has(vid)) continue;
+    const curatorLo = normLowerId(v.curator ?? void 0);
+    const curatorName = curatorLo && entityByAddr.has(curatorLo) ? entityByAddr.get(curatorLo) : curatorLo ? `${curatorLo.slice(0, 6)}\u2026${curatorLo.slice(-4)}` : "\u2014";
+    const strategiesRaw = [...v.strategies ?? []];
+    const sumStratAlloc = strategiesRaw.reduce((a, s) => a + big(s.allocatedAssets), 0n);
+    const totalAssets = big(v.totalAssets);
+    const totalAllocatedField = big(v.totalAllocated);
+    let denomForApy = sumStratAlloc;
+    if (denomForApy === 0n) denomForApy = totalAllocatedField;
+    let weightedApyRay = 0n;
+    if (denomForApy > 0n) {
+      let acc = 0n;
+      for (const s of strategiesRaw) {
+        const alloc = big(s.allocatedAssets);
+        const sid = normLowerId(s.strategy ?? void 0);
+        const meta = sid ? apyByVault.get(sid) : void 0;
+        const ray = meta?.apyRay ?? 0n;
+        acc += ray * alloc;
+      }
+      weightedApyRay = acc / denomForApy;
+    }
+    const supplyApyPercentLabel = denomForApy > 0n ? formatEulerRayApyPercent(weightedApyRay) : "0.00%";
+    const deployedForLiquidity = sumStratAlloc > 0n ? sumStratAlloc : totalAllocatedField > 0n ? totalAllocatedField : 0n;
+    const availableWei = totalAssets > deployedForLiquidity ? totalAssets - deployedForLiquidity : 0n;
+    const performanceFee = big(v.performanceFee);
+    const performanceFeePercentLabel = formatPerformanceFeePercent(performanceFee);
+    const vaultName = (v.name ?? "").trim() || "Euler Earn";
+    const stratRows = strategiesRaw.map((s) => {
+      const sid = normLowerId(s.strategy ?? void 0) ?? "";
+      const meta = sid ? apyByVault.get(sid) : void 0;
+      const alloc = big(s.allocatedAssets);
+      const cap = big(s.currentAllocationCap);
+      const pctOfTotal = totalAssets > 0n ? `${(Number(alloc * 10000n / totalAssets) / 100).toFixed(1)}%` : "0.0%";
+      const capUnlimited = isUnboundedEarnStrategyAllocationCap(cap);
+      let capLabel;
+      if (capUnlimited) {
+        capLabel = "\u221E";
+      } else if (cap === 0n) {
+        capLabel = `0${tic ? ` ${tic}` : ""}`;
+      } else {
+        try {
+          capLabel = `${viem.formatUnits(cap, dec)}${tic ? ` ${tic}` : ""}`;
+        } catch {
+          capLabel = cap.toString();
+        }
+      }
+      let allocHuman;
+      try {
+        allocHuman = `${viem.formatUnits(alloc, dec)}${tic ? ` ${tic}` : ""}`;
+      } catch {
+        allocHuman = alloc.toString();
+      }
+      return {
+        strategyVaultIdLower: sid,
+        strategySymbol: meta?.symbol ?? "\u2014",
+        supplyApyPercentLabel: meta ? formatEulerRayApyPercent(meta.apyRay) : "\u2014",
+        allocatedAssetsWei: alloc,
+        allocatedHumanLabel: allocHuman,
+        allocationPercentOfTvlLabel: pctOfTotal,
+        allocationCapHumanLabel: capLabel,
+        allocationCapUnlimited: capUnlimited
+      };
+    });
+    const cs = checksumHex2(v.id);
+    if (!cs) continue;
+    let totalHuman;
+    let availHuman;
+    try {
+      totalHuman = `${viem.formatUnits(totalAssets, dec)}${tic ? ` ${tic}` : ""}`;
+      availHuman = `${viem.formatUnits(availableWei, dec)}${tic ? ` ${tic}` : ""}`;
+    } catch {
+      totalHuman = totalAssets.toString();
+      availHuman = availableWei.toString();
+    }
+    out.push({
+      vaultIdLower: vid,
+      evaultAddress: cs,
+      vaultName,
+      curatorDisplayName: curatorName,
+      strategyCount: strategiesRaw.length,
+      supplyApyPercentLabel,
+      totalAssetsWei: totalAssets,
+      totalAssetsHumanLabel: totalHuman,
+      availableLiquidityWei: availableWei,
+      availableLiquidityHumanLabel: availHuman,
+      performanceFeePercentLabel,
+      underlyingDecimals: dec,
+      strategies: stratRows
+    });
+  }
+  out.sort((a, b) => {
+    const ap = Number.parseFloat(a.supplyApyPercentLabel.replace("%", "")) || 0;
+    const bp = Number.parseFloat(b.supplyApyPercentLabel.replace("%", "")) || 0;
+    if (bp !== ap) return bp - ap;
+    return a.vaultName.localeCompare(b.vaultName);
+  });
+  return out;
+}
+function checksumHex2(raw) {
+  const s = (raw ?? "").trim();
+  if (!s || !viem.isAddress(s)) return null;
+  try {
+    return viem.getAddress(s);
+  } catch {
+    return null;
+  }
+}
+var eulerVaultRiskAbi = viem.parseAbi([
+  "function LTVBorrow(address collateral) view returns (uint16)",
+  "function LTVLiquidation(address collateral) view returns (uint16)"
+]);
+var priceOracleAbi = viem.parseAbi([
+  "function getQuote(uint256 inAmount, address base, address quote) view returns (uint256 outAmount)"
+]);
+function metaClient(chainId, rpcUrl) {
+  const chain = viem.defineChain({
+    id: chainId,
+    name: "EulerBorrowRisk",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return viem.createPublicClient({ chain, transport: viem.http(rpcUrl) });
+}
+async function fetchEulerV2BorrowPairLtvs(args) {
+  const rpc = (args.rpcUrl ?? "").trim();
+  if (!rpc) return null;
+  try {
+    const client = metaClient(args.chainId, rpc);
+    const coll = viem.getAddress(args.collateralEvault);
+    const bor = viem.getAddress(args.borrowEvault);
+    const [maxLt, liqLt] = await Promise.all([
+      client.readContract({ address: bor, abi: eulerVaultRiskAbi, functionName: "LTVBorrow", args: [coll] }),
+      client.readContract({ address: bor, abi: eulerVaultRiskAbi, functionName: "LTVLiquidation", args: [coll] })
+    ]);
+    return { maxLtvBps: Number(maxLt), liquidationLtvBps: Number(liqLt) };
+  } catch {
+    return null;
+  }
+}
+async function fetchEulerV2BorrowOracleQuoteSnapshot(args) {
+  const rpc = (args.rpcUrl ?? "").trim();
+  if (!rpc) return null;
+  if (!viem.isAddress(args.oracle) || !viem.isAddress(args.unitOfAccount)) return null;
+  try {
+    const client = metaClient(args.chainId, rpc);
+    const oracle = viem.getAddress(args.oracle);
+    const uoa = viem.getAddress(args.unitOfAccount);
+    const bAss = viem.getAddress(args.borrowAsset);
+    const cAss = viem.getAddress(args.collateralAsset);
+    const oneBorrow = viem.parseUnits("1", args.borrowDecimals);
+    const collWei = viem.parseUnits(args.collateralAmountHuman, args.collateralDecimals);
+    const [oneBorrowUnitUoAWei, collateralUoAWei] = await Promise.all([
+      client.readContract({
+        address: oracle,
+        abi: priceOracleAbi,
+        functionName: "getQuote",
+        args: [oneBorrow, bAss, uoa]
+      }),
+      collWei > 0n ? client.readContract({
+        address: oracle,
+        abi: priceOracleAbi,
+        functionName: "getQuote",
+        args: [collWei, cAss, uoa]
+      }) : Promise.resolve(0n)
+    ]);
+    return { oneBorrowUnitUoAWei, collateralUoAWei };
+  } catch {
+    return null;
+  }
+}
+function estimateBorrowHumanFromLtv(args) {
+  if (args.collateralUoAWei <= 0n || args.oneBorrowUnitUoAWei <= 0n || !(args.ltvPercent > 0)) return "0";
+  const bps = Math.min(1e4, Math.max(0, Math.round(args.ltvPercent * 100)));
+  const debtUoA = args.collateralUoAWei * BigInt(bps) / 10000n;
+  const borrowWei = debtUoA * viem.parseUnits("1", args.borrowDecimals) / args.oneBorrowUnitUoAWei;
+  if (borrowWei <= 0n) return "0";
+  return viem.formatUnits(borrowWei, args.borrowDecimals);
+}
+function maxCollateralWeiCappedByBorrowLiquidity(args) {
+  const { walletBalWei, maxBorrowWei, collateralFullUoAWei, oneBorrowUnitUoAWei, ltvPercent, borrowDecimals } = args;
+  if (walletBalWei <= 0n) return 0n;
+  if (maxBorrowWei <= 0n) return 0n;
+  if (!(ltvPercent > 0)) return walletBalWei;
+  if (collateralFullUoAWei <= 0n || oneBorrowUnitUoAWei <= 0n) return walletBalWei;
+  const bps = Math.min(1e4, Math.max(0, Math.round(ltvPercent * 100)));
+  const debtUoA = collateralFullUoAWei * BigInt(bps) / 10000n;
+  const borrowWeiFull = debtUoA * viem.parseUnits("1", borrowDecimals) / oneBorrowUnitUoAWei;
+  if (borrowWeiFull <= 0n) return walletBalWei;
+  if (borrowWeiFull <= maxBorrowWei) return walletBalWei;
+  return walletBalWei * maxBorrowWei / borrowWeiFull;
+}
+
+// src/protocols/evm/euler-v2/eulerV2BorrowPositionsLoad.ts
+var TRACKING_BORROWS = `
+query EulerTrackingBorrows($id: Bytes!) {
+  trackingActiveAccount(id: $id) {
+    borrows
+  }
+}`;
+var VAULTS_FOR_EVAULTS = `
+query EulerVaultsForBorrows($ids: [ID!]!) {
+  eulerVaults(where: { id_in: $ids }) {
+    id
+    evault
+    evc
+    name
+    symbol
+    asset
+    decimals
+    collaterals
+  }
+}`;
+var erc20DecimalsAbi2 = viem.parseAbi(["function decimals() view returns (uint8)"]);
+var erc4626BalanceAbi = viem.parseAbi(["function balanceOf(address account) view returns (uint256)"]);
+var erc4626MaxWithdrawAbi2 = viem.parseAbi(["function maxWithdraw(address owner) view returns (uint256)"]);
+var eulerRiskLtAbi = viem.parseAbi(["function LTVBorrow(address collateral) view returns (uint16)"]);
+var eulerLiquidityAbi = viem.parseAbi([
+  "function accountLiquidity(address account, bool liquidation) view returns (uint256 collateralValue, uint256 liabilityValue)"
+]);
+function metaClient2(chainId, rpcUrl) {
+  const chain = viem.defineChain({
+    id: chainId,
+    name: "EulerBorrowPos",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return viem.createPublicClient({ chain, transport: viem.http(rpcUrl) });
+}
+function parseEulerTrackingBorrowEntry(entry) {
+  const s = (entry ?? "").trim().toLowerCase();
+  if (!s.startsWith("0x")) return null;
+  const hex = s.slice(2);
+  if (hex.length < 80) return null;
+  try {
+    const subAccount = viem.getAddress(`0x${hex.slice(0, 40)}`);
+    const borrowVault = viem.getAddress(`0x${hex.slice(40, 80)}`);
+    return { subAccount, borrowVault };
+  } catch {
+    return null;
+  }
+}
+async function fetchEulerV2TrackingBorrowEntries(args) {
+  const id = args.mainAddress.toLowerCase();
+  const data = await eulerV2QueryGraphQl(
+    args.chainId,
+    TRACKING_BORROWS,
+    { id }
+  );
+  const raw = data.trackingActiveAccount?.borrows ?? [];
+  return raw.filter((x) => typeof x === "string" && x.trim().length > 0);
+}
+async function pickCollateralEvault(args) {
+  const cands = (args.collaterals ?? []).map((c) => (c ?? "").trim().toLowerCase()).filter((c) => c.startsWith("0x") && viem.isAddress(c));
+  const uniq = [...new Set(cands)];
+  for (const low of uniq) {
+    try {
+      const coll = viem.getAddress(low);
+      const lt = await args.client.readContract({
+        address: args.borrowVault,
+        abi: eulerRiskLtAbi,
+        functionName: "LTVBorrow",
+        args: [coll]
+      });
+      if (Number(lt) === 0) continue;
+      const bal = await args.client.readContract({
+        address: coll,
+        abi: erc4626BalanceAbi,
+        functionName: "balanceOf",
+        args: [args.subAccount]
+      });
+      if (bal > 0n) return coll;
+    } catch {
+    }
+  }
+  for (const low of uniq) {
+    try {
+      const coll = viem.getAddress(low);
+      const lt = await args.client.readContract({
+        address: args.borrowVault,
+        abi: eulerRiskLtAbi,
+        functionName: "LTVBorrow",
+        args: [coll]
+      });
+      if (Number(lt) > 0) return coll;
+    } catch {
+    }
+  }
+  if (uniq.length) {
+    try {
+      return viem.getAddress(uniq[0]);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function loadEulerV2BorrowPositionsForOwner(args) {
+  const rpc = args.rpcUrl.trim();
+  if (!rpc) return [];
+  const [entries, depositEntries] = await Promise.all([
+    fetchEulerV2TrackingBorrowEntries({ chainId: args.chainId, mainAddress: args.mainAddress }),
+    fetchEulerV2TrackingDepositEntries({ chainId: args.chainId, mainAddress: args.mainAddress })
+  ]);
+  const pairKey = (sub, vault) => `${sub.toLowerCase()}-${vault.toLowerCase()}`;
+  const seenPairs = /* @__PURE__ */ new Set();
+  const pairs = [];
+  const pushPair = (sub, vault) => {
+    const k = pairKey(sub, vault);
+    if (seenPairs.has(k)) return;
+    seenPairs.add(k);
+    pairs.push({ subAccount: sub, borrowVault: vault });
+  };
+  for (const e of entries) {
+    const p = parseEulerTrackingBorrowEntry(e);
+    if (p) pushPair(p.subAccount, p.borrowVault);
+  }
+  const client = metaClient2(args.chainId, rpc);
+  const debtAbi = viem.parseAbi(["function debtOf(address account) view returns (uint256)"]);
+  for (const e of depositEntries) {
+    const p = parseEulerTrackingBorrowEntry(e);
+    if (!p) continue;
+    if (seenPairs.has(pairKey(p.subAccount, p.borrowVault))) continue;
+    let debtWei = 0n;
+    try {
+      debtWei = await client.readContract({
+        address: p.borrowVault,
+        abi: debtAbi,
+        functionName: "debtOf",
+        args: [p.subAccount]
+      });
+    } catch {
+      continue;
+    }
+    if (debtWei === 0n) continue;
+    pushPair(p.subAccount, p.borrowVault);
+  }
+  if (!pairs.length) return [];
+  const vaultIds = [...new Set(pairs.map((x) => x.borrowVault.toLowerCase()))];
+  const vaultData = await eulerV2QueryGraphQl(args.chainId, VAULTS_FOR_EVAULTS, { ids: vaultIds });
+  const byEvault = /* @__PURE__ */ new Map();
+  for (const v of vaultData.eulerVaults ?? []) {
+    const ev = (v.evault ?? "").trim().toLowerCase();
+    if (ev) byEvault.set(ev, v);
+  }
+  const evcAbi5 = viem.parseAbi(["function EVC() view returns (address)"]);
+  const out = [];
+  const t = Date.now();
+  for (const { subAccount, borrowVault } of pairs) {
+    let debtWei = 0n;
+    try {
+      debtWei = await client.readContract({
+        address: borrowVault,
+        abi: debtAbi,
+        functionName: "debtOf",
+        args: [subAccount]
+      });
+    } catch {
+    }
+    const vrow = byEvault.get(borrowVault.toLowerCase());
+    const decRaw = Number((vrow?.decimals ?? "18").toString().trim() || "18");
+    const decimals = Number.isFinite(decRaw) && decRaw >= 0 && decRaw <= 36 ? decRaw : 18;
+    let assetLow = (vrow?.asset ?? "").trim().toLowerCase();
+    if (!assetLow || !viem.isAddress(assetLow)) {
+      try {
+        const a = await client.readContract({
+          address: borrowVault,
+          abi: viem.parseAbi(["function asset() view returns (address)"]),
+          functionName: "asset"
+        });
+        assetLow = viem.getAddress(a).toLowerCase();
+      } catch {
+        assetLow = "";
+      }
+    }
+    let decFinal = decimals;
+    if (assetLow && viem.isAddress(assetLow)) {
+      try {
+        const d = await client.readContract({
+          address: viem.getAddress(assetLow),
+          abi: erc20DecimalsAbi2,
+          functionName: "decimals"
+        });
+        const n = Number(d);
+        if (Number.isFinite(n) && n >= 0 && n <= 36) decFinal = n;
+      } catch {
+      }
+    }
+    const debtHuman = viem.formatUnits(debtWei, decFinal);
+    const collateralVault = await pickCollateralEvault({
+      client,
+      borrowVault,
+      subAccount,
+      collaterals: vrow?.collaterals ?? null
+    });
+    if (debtWei === 0n) {
+      if (!collateralVault) continue;
+      let maxWithdrawLeft = 0n;
+      try {
+        maxWithdrawLeft = await client.readContract({
+          address: collateralVault,
+          abi: erc4626MaxWithdrawAbi2,
+          functionName: "maxWithdraw",
+          args: [subAccount]
+        });
+      } catch {
+        maxWithdrawLeft = 0n;
+      }
+      let collateralShares = 0n;
+      if (maxWithdrawLeft === 0n) {
+        try {
+          collateralShares = await client.readContract({
+            address: collateralVault,
+            abi: erc4626BalanceAbi,
+            functionName: "balanceOf",
+            args: [subAccount]
+          });
+        } catch {
+          collateralShares = 0n;
+        }
+      }
+      if (maxWithdrawLeft === 0n && collateralShares === 0n) continue;
+    }
+    let collateralAssetAddressLower = null;
+    let collateralAssetDecimals;
+    let collateralUnderlyingSymbol = null;
+    if (collateralVault) {
+      try {
+        const assetAddr = await client.readContract({
+          address: collateralVault,
+          abi: viem.parseAbi(["function asset() view returns (address)"]),
+          functionName: "asset"
+        });
+        const cLow = viem.getAddress(assetAddr).toLowerCase();
+        collateralAssetAddressLower = cLow;
+        const cd = await client.readContract({
+          address: viem.getAddress(cLow),
+          abi: erc20DecimalsAbi2,
+          functionName: "decimals"
+        });
+        const cn = Number(cd);
+        if (Number.isFinite(cn) && cn >= 0 && cn <= 36) collateralAssetDecimals = cn;
+        try {
+          const sym = await client.readContract({
+            address: viem.getAddress(cLow),
+            abi: viem.parseAbi(["function symbol() view returns (string)"]),
+            functionName: "symbol"
+          });
+          const s = typeof sym === "string" ? sym.trim() : "";
+          if (s) collateralUnderlyingSymbol = s;
+        } catch {
+        }
+      } catch {
+      }
+    }
+    let maxLtvBps = null;
+    let liquidationLtvBps = null;
+    if (collateralVault) {
+      const risk = await fetchEulerV2BorrowPairLtvs({
+        chainId: args.chainId,
+        rpcUrl: rpc,
+        borrowEvault: borrowVault,
+        collateralEvault: collateralVault
+      });
+      if (risk) {
+        maxLtvBps = risk.maxLtvBps;
+        liquidationLtvBps = risk.liquidationLtvBps;
+      }
+    }
+    let currentLtvPercent = null;
+    try {
+      const [collV, liabV] = await client.readContract({
+        address: borrowVault,
+        abi: eulerLiquidityAbi,
+        functionName: "accountLiquidity",
+        args: [subAccount, false]
+      });
+      if (collV > 0n && liabV > 0n) {
+        currentLtvPercent = Number(liabV * 10000n / collV) / 100;
+      }
+    } catch {
+    }
+    let evc = (vrow?.evc ?? "").trim() ? viem.getAddress(vrow.evc.trim()) : null;
+    if (!evc) {
+      try {
+        const e = await client.readContract({
+          address: borrowVault,
+          abi: evcAbi5,
+          functionName: "EVC"
+        });
+        evc = viem.getAddress(e);
+      } catch {
+        evc = null;
+      }
+    }
+    const marketName = [(vrow?.symbol ?? "").trim(), (vrow?.name ?? "").trim()].filter(Boolean).join(" \xB7 ") || `Borrow ${borrowVault.slice(0, 10)}\u2026`;
+    out.push({
+      id: `borrow-${args.chainId}-${subAccount.toLowerCase()}-${borrowVault.toLowerCase()}`,
+      chainId: args.chainId,
+      vaultId: (vrow?.id ?? borrowVault).toString(),
+      evaultAddress: borrowVault,
+      marketName,
+      underlyingSymbol: (vrow?.symbol ?? "\u2014").toString().trim() || "\u2014",
+      amountHuman: debtHuman,
+      createdAtMs: t,
+      signRequestId: null,
+      positionKind: "borrow",
+      subAccountAddress: subAccount,
+      collateralEvaultAddress: collateralVault,
+      evcAddress: evc,
+      borrowAssetAddressLower: assetLow || null,
+      borrowAssetDecimals: decFinal,
+      borrowDebtHuman: debtHuman,
+      collateralAssetAddressLower,
+      collateralAssetDecimals,
+      collateralUnderlyingSymbol,
+      currentLtvPercent,
+      maxLtvBps,
+      liquidationLtvBps
+    });
+  }
+  return out.sort((a, b) => (a.marketName || "").localeCompare(b.marketName || ""));
+}
+async function fetchEulerV2BorrowDebtWei(args) {
+  const rpc = args.rpcUrl.trim();
+  if (!rpc) return 0n;
+  const client = metaClient2(args.chainId, rpc);
+  const debtAbi = viem.parseAbi(["function debtOf(address account) view returns (uint256)"]);
+  try {
+    return await client.readContract({
+      address: args.borrowVault,
+      abi: debtAbi,
+      functionName: "debtOf",
+      args: [args.subAccount]
+    });
+  } catch {
+    return 0n;
+  }
+}
+var VAULTS_FOR_EVAULTS2 = `
+query EulerVaultsForSupply($ids: [ID!]!) {
+  eulerVaults(where: { id_in: $ids }) {
+    id
+    evault
+    name
+    symbol
+    asset
+    decimals
+  }
+}`;
+var vaultSupplyAbi = viem.parseAbi([
+  "function balanceOf(address account) view returns (uint256)",
+  "function convertToAssets(uint256 shares) view returns (uint256)",
+  "function asset() view returns (address)"
+]);
+var debtOfAbi = viem.parseAbi(["function debtOf(address account) view returns (uint256)"]);
+function metaClient3(chainId, rpcUrl) {
+  const chain = viem.defineChain({
+    id: chainId,
+    name: "EulerLendSupply",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return viem.createPublicClient({ chain, transport: viem.http(rpcUrl) });
+}
+async function readSupplyUnderlyingWei(client, vault, shareOwner) {
+  try {
+    const shares = await client.readContract({
+      address: vault,
+      abi: vaultSupplyAbi,
+      functionName: "balanceOf",
+      args: [shareOwner]
+    });
+    if (shares === 0n) return null;
+    const assets = await client.readContract({
+      address: vault,
+      abi: vaultSupplyAbi,
+      functionName: "convertToAssets",
+      args: [shares]
+    });
+    if (assets === 0n) return null;
+    const asset = await client.readContract({
+      address: vault,
+      abi: vaultSupplyAbi,
+      functionName: "asset"
+    });
+    return { asset: viem.getAddress(asset), wei: assets };
+  } catch {
+    return null;
+  }
+}
+async function loadEulerV2LendSupplyPositionsForOwner(args) {
+  const rpc = args.rpcUrl.trim();
+  if (!rpc) return [];
+  if (!eulerV2GoldskyUrlForChain(args.chainId)) return [];
+  const [entries, earnVaultAllowlist, gasAliases] = await Promise.all([
+    fetchEulerV2TrackingDepositEntries({ chainId: args.chainId, mainAddress: args.mainAddress }),
+    fetchEulerLabelsEarnVaultAllowlist(args.chainId),
+    eulerWrappedGasTokenAliasesLower(args.chainId)
+  ]);
+  const pairs = [];
+  for (const e of entries) {
+    const p = parseEulerTrackingBorrowEntry(e);
+    if (p) pairs.push({ subAccount: p.subAccount, evault: p.borrowVault });
+  }
+  if (!pairs.length) return [];
+  const vaultIds = [...new Set(pairs.map((x) => x.evault.toLowerCase()))];
+  const vaultData = await eulerV2QueryGraphQl(args.chainId, VAULTS_FOR_EVAULTS2, { ids: vaultIds });
+  const byEvault = /* @__PURE__ */ new Map();
+  for (const v of vaultData.eulerVaults ?? []) {
+    const ev = (v.evault ?? "").trim().toLowerCase();
+    if (ev) byEvault.set(ev, v);
+  }
+  const client = metaClient3(args.chainId, rpc);
+  const t = Date.now();
+  const out = [];
+  const seenPair = /* @__PURE__ */ new Set();
+  for (const { subAccount, evault } of pairs) {
+    const pairKey = `${subAccount.toLowerCase()}-${evault.toLowerCase()}`;
+    if (seenPair.has(pairKey)) continue;
+    seenPair.add(pairKey);
+    const supply = await readSupplyUnderlyingWei(client, evault, subAccount);
+    if (!supply) continue;
+    let liabilityDebtWei = 0n;
+    try {
+      liabilityDebtWei = await client.readContract({
+        address: evault,
+        abi: debtOfAbi,
+        functionName: "debtOf",
+        args: [subAccount]
+      });
+    } catch {
+      liabilityDebtWei = 0n;
+    }
+    if (liabilityDebtWei > 0n) continue;
+    const vrow = byEvault.get(evault.toLowerCase());
+    const isEarn = earnVaultAllowlist.has(evault.toLowerCase());
+    const positionKind = isEarn ? "earn" : "lend";
+    const underlyingSymbol = (vrow?.symbol ?? "\u2014").toString().trim() || "\u2014";
+    const marketName = [(vrow?.symbol ?? "").trim(), (vrow?.name ?? "").trim()].filter(Boolean).join(" \xB7 ") || `${isEarn ? "Earn" : "Lend"} ${evault.slice(0, 10)}\u2026`;
+    let evChecksummed;
+    try {
+      evChecksummed = viem.getAddress(evault);
+    } catch {
+      continue;
+    }
+    let vaultMeta;
+    try {
+      vaultMeta = await fetchEulerVaultUnderlyingMeta({
+        rpcUrl: rpc,
+        chainId: args.chainId,
+        evault: evChecksummed
+      });
+    } catch {
+      continue;
+    }
+    const decimals = clampEulerUnderlyingDecimalsForEulerUi({
+      fetchedDecimals: vaultMeta.decimals,
+      underlyingAssetLower: vaultMeta.asset.toLowerCase(),
+      marketName,
+      underlyingSymbol,
+      wrappedGasAliasesLower: gasAliases
+    });
+    const amountHuman = viem.formatUnits(supply.wei, decimals);
+    out.push({
+      id: `${positionKind}-supply-${args.chainId}-${subAccount.toLowerCase()}-${evault.toLowerCase()}`,
+      chainId: args.chainId,
+      vaultId: (vrow?.id ?? evault).toString(),
+      evaultAddress: evault,
+      marketName,
+      underlyingSymbol,
+      amountHuman,
+      underlyingAssetsWei: supply.wei.toString(),
+      underlyingAssetAddressLower: vaultMeta.asset.toLowerCase(),
+      createdAtMs: t,
+      signRequestId: null,
+      positionKind,
+      subAccountAddress: subAccount,
+      underlyingAssetDecimals: decimals
+    });
+  }
+  return out.sort((a, b) => (a.marketName || "").localeCompare(b.marketName || ""));
+}
+function mergeEulerV2PositionsTabRows(args) {
+  const main = args.mainAddressLower.trim().toLowerCase();
+  const keyOf = (p) => {
+    const kind = p.positionKind ?? "lend";
+    if (kind === "borrow") return p.id;
+    const ev = p.evaultAddress.trim().toLowerCase();
+    const sub = (p.subAccountAddress ?? main).trim().toLowerCase();
+    return `supply|${ev}|${sub}`;
+  };
+  const chainKeys = new Set(args.chainSupply.map(keyOf));
+  const sessionFiltered = args.session.filter((s) => !chainKeys.has(keyOf(s)));
+  return [...args.borrow, ...args.chainSupply, ...sessionFiltered];
+}
+var REUL_LOCK_DAY_SEC = 86400n;
+var REUL_FULL_VEST_SEC = 180n * REUL_LOCK_DAY_SEC;
+var rewardTokenReadAbi = viem.parseAbi([
+  "function getLockedAmounts(address account) view returns (uint256[] lockTimestamps, uint256[] amounts)",
+  "function getWithdrawAmountsByLockTimestamp(address account, uint256 lockTimestamp) view returns (uint256 accountAmount, uint256 remainderAmount)"
+]);
+var eulerReulUnlockAbi = viem.parseAbi([
+  "function withdrawToByLockTimestamps(address account, uint256[] lockTimestamps, bool allowRemainderLoss) returns (bool)"
+]);
+async function fetchEulerReulVestingTranches(args) {
+  const rpc = args.rpcUrl.trim();
+  if (!rpc) return [];
+  const reul = viem.getAddress(args.reulToken);
+  const user = viem.getAddress(args.user);
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "ReulVest",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const client = viem.createPublicClient({ chain: ch, transport: viem.http(rpc) });
+  const [timestamps, amounts] = await client.readContract({
+    address: reul,
+    abi: rewardTokenReadAbi,
+    functionName: "getLockedAmounts",
+    args: [user]
+  });
+  const out = [];
+  for (let i = 0; i < timestamps.length; i++) {
+    const lockTs = timestamps[i];
+    const lockedAmt = amounts[i];
+    if (lockedAmt === 0n) continue;
+    const [unlockToWalletWei, remainderWei] = await client.readContract({
+      address: reul,
+      abi: rewardTokenReadAbi,
+      functionName: "getWithdrawAmountsByLockTimestamp",
+      args: [user, lockTs]
+    });
+    out.push({
+      reulToken: reul,
+      lockTimestampSec: lockTs,
+      lockedAmountWei: lockedAmt,
+      unlockToWalletWei,
+      remainderWei,
+      fullVestTimestampSec: lockTs + REUL_FULL_VEST_SEC,
+      isFullyVested: remainderWei === 0n
+    });
+  }
+  return out;
+}
+function encodeEulerReulWithdrawToByLockTimestampsData(args) {
+  const recipient = viem.getAddress(args.recipient);
+  if (args.lockTimestampsSec.length === 0) throw new Error("No rEUL lock timestamps to unlock.");
+  return viem.encodeFunctionData({
+    abi: eulerReulUnlockAbi,
+    functionName: "withdrawToByLockTimestamps",
+    args: [recipient, [...args.lockTimestampsSec], args.allowRemainderLoss]
+  });
+}
+var EULER_REUL_UNLOCK_GAS_FALLBACK = 500000n;
+
+// src/chains/evm/coingecko.ts
+var COINGECKO_PLATFORM_BY_CHAIN_ID = {
+  "1": "ethereum",
+  "56": "binance-smart-chain",
+  "137": "polygon-pos",
+  "42161": "arbitrum-one",
+  "10": "optimistic-ethereum",
+  "43114": "avalanche",
+  "8453": "base",
+  "324": "zk-sync-era",
+  "42220": "celo",
+  "250": "fantom",
+  "100": "gnosis",
+  "204": "op-bnb",
+  "534352": "scroll",
+  "5000": "mantle",
+  "169": "manta-pacific",
+  "1116": "core",
+  "30": "rootstock",
+  "288": "boba",
+  "1088": "metis-andromeda",
+  "34443": "mode",
+  "80084": "berachain",
+  "146": "sonic",
+  "60808": "bob-network",
+  "80094": "berachain",
+  "130": "unichain",
+  "57073": "ink",
+  "999": "hyperevm",
+  "239": "tac",
+  "9745": "plasma",
+  "1923": "swellchain",
+  "59144": "linea",
+  "81457": "blast",
+  "7777777": "zora"
+};
+
+// src/protocols/evm/euler-v2/eulerV2PortfolioUsd.ts
+var TRACKING_ACCOUNT = `
+query EulerTrackingAccount($id: Bytes!) {
+  trackingActiveAccount(id: $id) {
+    deposits
+    borrows
+  }
+}`;
+var vaultSupplyAbi2 = viem.parseAbi([
+  "function balanceOf(address account) view returns (uint256)",
+  "function convertToAssets(uint256 shares) view returns (uint256)",
+  "function asset() view returns (address)"
+]);
+var erc20DecimalsAbi3 = viem.parseAbi(["function decimals() view returns (uint8)"]);
+var debtOfAbi2 = viem.parseAbi(["function debtOf(address account) view returns (uint256)"]);
+function publicClient(chainId, rpcUrl) {
+  const ch = viem.defineChain({
+    id: chainId,
+    name: "EulerPortfolio",
+    nativeCurrency: { decimals: 18, name: "x", symbol: "x" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
+}
+async function gqlTrackingAccount(chainId, mainLower) {
+  if (!eulerV2GoldskyUrlForChain(chainId)) {
+    return { deposits: [], borrows: [] };
+  }
+  const data = await eulerV2QueryGraphQl(chainId, TRACKING_ACCOUNT, { id: mainLower });
+  const a = data.trackingActiveAccount;
+  const dep = (a?.deposits ?? []).filter((x) => typeof x === "string" && x.trim().length > 0);
+  const bor = (a?.borrows ?? []).filter((x) => typeof x === "string" && x.trim().length > 0);
+  return { deposits: dep, borrows: bor };
+}
+async function decimalsForAsset(client, asset) {
+  try {
+    const d = await client.readContract({
+      address: asset,
+      abi: erc20DecimalsAbi3,
+      functionName: "decimals"
+    });
+    const n = Number(d);
+    if (Number.isFinite(n) && n >= 0 && n <= 36) return n;
+  } catch {
+  }
+  return 18;
+}
+async function readSupplyUnderlyingWei2(client, vault, subAccount) {
+  try {
+    const shares = await client.readContract({
+      address: vault,
+      abi: vaultSupplyAbi2,
+      functionName: "balanceOf",
+      args: [subAccount]
+    });
+    if (shares === 0n) return null;
+    const assets = await client.readContract({
+      address: vault,
+      abi: vaultSupplyAbi2,
+      functionName: "convertToAssets",
+      args: [shares]
+    });
+    if (assets === 0n) return null;
+    const asset = await client.readContract({
+      address: vault,
+      abi: vaultSupplyAbi2,
+      functionName: "asset"
+    });
+    return { asset: viem.getAddress(asset), wei: assets };
+  } catch {
+    return null;
+  }
+}
+async function readBorrowDebtWei(client, borrowVault, subAccount) {
+  try {
+    const debt = await client.readContract({
+      address: borrowVault,
+      abi: debtOfAbi2,
+      functionName: "debtOf",
+      args: [subAccount]
+    });
+    if (debt === 0n) return null;
+    const asset = await client.readContract({
+      address: borrowVault,
+      abi: vaultSupplyAbi2,
+      functionName: "asset"
+    });
+    return { asset: viem.getAddress(asset), wei: debt };
+  } catch {
+    return null;
+  }
+}
+function mergeWei(into, asset, wei) {
+  const k = asset.toLowerCase();
+  into.set(k, (into.get(k) ?? 0n) + wei);
+}
+async function fetchCoingeckoContractUsdFromDetail(args) {
+  const a = args.contractAddressLower.trim().toLowerCase();
+  if (!a.startsWith("0x")) return null;
+  const url = `https://api.coingecko.com/api/v3/coins/${encodeURIComponent(args.platform)}/contract/${a}`;
+  try {
+    const r = await fetch(url, { cache: "no-store" });
+    if (!r.ok) return null;
+    const j = await r.json();
+    const u = j.market_data?.current_price?.usd;
+    if (typeof u !== "number" || !Number.isFinite(u) || u < 0) return null;
+    return u;
+  } catch {
+    return null;
+  }
+}
+async function augmentMissingTokenPrices(args) {
+  const missing = args.addressesLower.map((x) => x.trim().toLowerCase()).filter((x) => x.startsWith("0x") && !args.prices.has(x));
+  for (const addr of missing.slice(0, 12)) {
+    const u = await fetchCoingeckoContractUsdFromDetail({ platform: args.platform, contractAddressLower: addr });
+    if (u != null) args.prices.set(addr, u);
+  }
+}
+var COINGECKO_CHUNK = 45;
+async function fetchCoingeckoTokenUsdByContract(args) {
+  const platform = COINGECKO_PLATFORM_BY_CHAIN_ID[String(args.chainId)];
+  const out = /* @__PURE__ */ new Map();
+  if (!platform || args.contractAddressesLower.length === 0) return out;
+  const uniq = [...new Set(args.contractAddressesLower.map((a) => a.trim().toLowerCase()).filter((a) => a.startsWith("0x")))];
+  for (let i = 0; i < uniq.length; i += COINGECKO_CHUNK) {
+    const chunk = uniq.slice(i, i + COINGECKO_CHUNK);
+    const url = `https://api.coingecko.com/api/v3/simple/token_price/${encodeURIComponent(platform)}?contract_addresses=${chunk.join(",")}&vs_currencies=usd`;
+    try {
+      const proxy = getCoingeckoProxyUrl();
+      const r = proxy ? await fetch(proxy, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ platform, contractAddresses: chunk })
+      }) : await fetch(url, { cache: "no-store" });
+      if (!r.ok) continue;
+      const j = await r.json();
+      for (const [addr, row] of Object.entries(j)) {
+        const u = row?.usd;
+        if (typeof u === "number" && Number.isFinite(u) && u >= 0) out.set(addr.toLowerCase(), u);
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+function sumSideUsd(args) {
+  let partial = false;
+  let total = 0;
+  let anyPriced = false;
+  let anyUnpricedNonZero = false;
+  const entries = [...args.byAssetWei.entries()].filter(([, w]) => w > 0n);
+  if (entries.length === 0) return { usd: 0, partial: false };
+  for (const [assetLow, wei] of entries) {
+    const dec = args.decimalsByAsset.get(assetLow) ?? 18;
+    const p = args.prices.get(assetLow);
+    if (p == null) {
+      partial = true;
+      anyUnpricedNonZero = true;
+      continue;
+    }
+    let humanAmt;
+    try {
+      humanAmt = Number.parseFloat(viem.formatUnits(wei, dec));
+    } catch {
+      partial = true;
+      anyUnpricedNonZero = true;
+      continue;
+    }
+    const slice = humanAmt * p;
+    if (!Number.isFinite(humanAmt) || !Number.isFinite(p) || !Number.isFinite(slice)) {
+      partial = true;
+      anyUnpricedNonZero = true;
+      continue;
+    }
+    anyPriced = true;
+    total += slice;
+  }
+  if (anyUnpricedNonZero && !anyPriced) return { usd: null, partial: true };
+  if (anyUnpricedNonZero) partial = true;
+  if (!Number.isFinite(total)) return { usd: null, partial: true };
+  return { usd: total, partial };
+}
+async function loadEulerV2PortfolioUsdSnapshot(args) {
+  const rpc = args.rpcUrl.trim();
+  const empty = {
+    totalSuppliedUsd: null,
+    totalBorrowedUsd: null,
+    netAssetValueUsd: null,
+    partialPricing: false,
+    pricingUnavailable: false,
+    error: null
+  };
+  if (!rpc) {
+    return { ...empty, error: "No RPC URL." };
+  }
+  const platform = COINGECKO_PLATFORM_BY_CHAIN_ID[String(args.chainId)];
+  try {
+    const mainLower = args.mainAddress.toLowerCase();
+    const { deposits, borrows } = await gqlTrackingAccount(args.chainId, mainLower);
+    const client = publicClient(args.chainId, rpc);
+    const suppliedWeiByAsset = /* @__PURE__ */ new Map();
+    const borrowedWeiByAsset = /* @__PURE__ */ new Map();
+    const borrowPairSeen = /* @__PURE__ */ new Set();
+    const borrowPairs = [];
+    const pushBorrowPair = (sub, vault) => {
+      const k = `${sub.toLowerCase()}-${vault.toLowerCase()}`;
+      if (borrowPairSeen.has(k)) return;
+      borrowPairSeen.add(k);
+      borrowPairs.push({ subAccount: sub, vault });
+    };
+    const supplyReads = [];
+    for (const entry of deposits) {
+      const p = parseEulerTrackingBorrowEntry(entry);
+      if (!p) continue;
+      pushBorrowPair(p.subAccount, p.borrowVault);
+      supplyReads.push(
+        (async () => {
+          const r = await readSupplyUnderlyingWei2(client, p.borrowVault, p.subAccount);
+          if (!r) return;
+          mergeWei(suppliedWeiByAsset, r.asset, r.wei);
+        })()
+      );
+    }
+    for (const entry of borrows) {
+      const p = parseEulerTrackingBorrowEntry(entry);
+      if (!p) continue;
+      pushBorrowPair(p.subAccount, p.borrowVault);
+    }
+    const borrowReads = borrowPairs.map(
+      ({ subAccount, vault }) => (async () => {
+        const r = await readBorrowDebtWei(client, vault, subAccount);
+        if (!r) return;
+        mergeWei(borrowedWeiByAsset, r.asset, r.wei);
+      })()
+    );
+    await Promise.all([...supplyReads, ...borrowReads]);
+    const allAssets = /* @__PURE__ */ new Set();
+    for (const [a, w] of suppliedWeiByAsset) if (w > 0n) allAssets.add(a.toLowerCase());
+    for (const [a, w] of borrowedWeiByAsset) if (w > 0n) allAssets.add(a.toLowerCase());
+    const decimalsByAsset = /* @__PURE__ */ new Map();
+    for (const low of allAssets) {
+      if (!viem.isAddress(low)) continue;
+      const dec = await decimalsForAsset(client, viem.getAddress(low));
+      decimalsByAsset.set(low.toLowerCase(), dec);
+    }
+    const prices = platform != null ? await fetchCoingeckoTokenUsdByContract({
+      chainId: args.chainId,
+      contractAddressesLower: [...allAssets]
+    }) : /* @__PURE__ */ new Map();
+    if (platform != null && allAssets.size > 0) {
+      await augmentMissingTokenPrices({
+        platform,
+        addressesLower: [...allAssets],
+        prices
+      });
+    }
+    const s = sumSideUsd({ byAssetWei: suppliedWeiByAsset, decimalsByAsset, prices });
+    const b = sumSideUsd({ byAssetWei: borrowedWeiByAsset, decimalsByAsset, prices });
+    const sUsd = s.usd != null && Number.isFinite(s.usd) ? s.usd : null;
+    const bUsd = b.usd != null && Number.isFinite(b.usd) ? b.usd : null;
+    let nav = null;
+    if (sUsd != null && bUsd != null) nav = sUsd - bUsd;
+    else if (sUsd != null && (borrowedWeiByAsset.size === 0 || [...borrowedWeiByAsset.values()].every((w) => w === 0n))) {
+      nav = sUsd;
+    } else if (bUsd != null && (suppliedWeiByAsset.size === 0 || [...suppliedWeiByAsset.values()].every((w) => w === 0n))) {
+      nav = -bUsd;
+    }
+    if (nav != null && !Number.isFinite(nav)) nav = null;
+    const hasAnyPosition = [...suppliedWeiByAsset.values(), ...borrowedWeiByAsset.values()].some((w) => w > 0n);
+    const partialPricing = s.partial || b.partial;
+    const pricingUnavailable = platform == null && hasAnyPosition;
+    return {
+      totalSuppliedUsd: sUsd,
+      totalBorrowedUsd: bUsd,
+      netAssetValueUsd: nav,
+      partialPricing: platform != null && partialPricing,
+      pricingUnavailable,
+      error: null
+    };
+  } catch (e) {
+    return {
+      ...empty,
+      error: e instanceof Error ? e.message : "Could not load portfolio."
+    };
+  }
+}
+
+// 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";
 var eulerV2ProtocolModule = {
@@ -1557,13 +3804,20 @@ var eulerV2ProtocolModule = {
 };
 registerProtocolModule(eulerV2ProtocolModule);
 
+exports.EULER_EVAULT_CAP_UNLIMITED_WEI = EULER_EVAULT_CAP_UNLIMITED_WEI;
+exports.EULER_EVAULT_SUPPLY_CAP_UNLIMITED_WEI = EULER_EVAULT_SUPPLY_CAP_UNLIMITED_WEI;
+exports.EULER_REUL_UNLOCK_GAS_FALLBACK = EULER_REUL_UNLOCK_GAS_FALLBACK;
 exports.EULER_SAME_ASSET_BORROW_APPROVAL_BUFFER_BPS = EULER_SAME_ASSET_BORROW_APPROVAL_BUFFER_BPS;
 exports.EULER_SAME_ASSET_BORROW_MAX_ROUNDS = EULER_SAME_ASSET_BORROW_MAX_ROUNDS;
 exports.EULER_SAME_ASSET_BORROW_PROTOCOL_HEADROOM_BPS = EULER_SAME_ASSET_BORROW_PROTOCOL_HEADROOM_BPS;
 exports.EULER_SAME_ASSET_BORROW_RATIO_STOP_EPS_BPS = EULER_SAME_ASSET_BORROW_RATIO_STOP_EPS_BPS;
+exports.EULER_V2_GOLDSKY_SUBGRAPH_URL_BY_CHAIN_ID = EULER_V2_GOLDSKY_SUBGRAPH_URL_BY_CHAIN_ID;
 exports.EULER_V2_ISOLATED_VAULT_DEPOSIT_FALLBACK_GAS = EULER_V2_ISOLATED_VAULT_DEPOSIT_FALLBACK_GAS;
+exports.EULER_V2_PREFER_ON_CHAIN_LEND_METRICS = EULER_V2_PREFER_ON_CHAIN_LEND_METRICS;
 exports.EULER_V2_PROTOCOL_ID = EULER_V2_PROTOCOL_ID;
 exports.EULER_V2_VAULT_WITHDRAW_FALLBACK_GAS = EULER_V2_VAULT_WITHDRAW_FALLBACK_GAS;
+exports.REUL_FULL_VEST_SEC = REUL_FULL_VEST_SEC;
+exports.REUL_LOCK_DAY_SEC = REUL_LOCK_DAY_SEC;
 exports.buildEvmMultisignBodyEulerV2BorrowCollateralDepositBatch = buildEvmMultisignBodyEulerV2BorrowCollateralDepositBatch;
 exports.buildEvmMultisignBodyEulerV2BorrowCollateralWithdrawBatch = buildEvmMultisignBodyEulerV2BorrowCollateralWithdrawBatch;
 exports.buildEvmMultisignBodyEulerV2BorrowRepayBatch = buildEvmMultisignBodyEulerV2BorrowRepayBatch;
@@ -1571,15 +3825,58 @@ exports.buildEvmMultisignBodyEulerV2IsolatedBorrowBatch = buildEvmMultisignBodyE
 exports.buildEvmMultisignBodyEulerV2IsolatedLendDepositBatch = buildEvmMultisignBodyEulerV2IsolatedLendDepositBatch;
 exports.buildEvmMultisignBodyEulerV2VaultWithdraw = buildEvmMultisignBodyEulerV2VaultWithdraw;
 exports.clampEulerUnderlyingDecimalsForEulerUi = clampEulerUnderlyingDecimalsForEulerUi;
+exports.encodeEulerReulWithdrawToByLockTimestampsData = encodeEulerReulWithdrawToByLockTimestampsData;
+exports.ensureEulerV2ChainAssetCache = ensureEulerV2ChainAssetCache;
+exports.estimateBorrowHumanFromLtv = estimateBorrowHumanFromLtv;
 exports.eulerBorrowAndCollateralSameAsset = eulerBorrowAndCollateralSameAsset;
+exports.eulerLabelsAppendUnderlyingIfDistinct = eulerLabelsAppendUnderlyingIfDistinct;
+exports.eulerLabelsLookupLabelForVault = eulerLabelsLookupLabelForVault;
+exports.eulerReulUnlockAbi = eulerReulUnlockAbi;
 exports.eulerSameAssetApproveAmountWithBuffer = eulerSameAssetApproveAmountWithBuffer;
 exports.eulerSameAssetTotalCollateralPullWei = eulerSameAssetTotalCollateralPullWei;
+exports.eulerSubgraphVaultCapToUnderlyingWei = eulerSubgraphVaultCapToUnderlyingWei;
+exports.eulerV2GoldskyUrlForChain = eulerV2GoldskyUrlForChain;
+exports.eulerV2KeyForNodeAssetRow = eulerV2KeyForNodeAssetRow;
 exports.eulerV2ProtocolModule = eulerV2ProtocolModule;
+exports.eulerV2QueryGraphQl = eulerV2QueryGraphQl;
+exports.eulerVaultLendMetricsFromIndexerVaultState = eulerVaultLendMetricsFromIndexerVaultState;
+exports.eulerVaultMaxNewBorrowWei = eulerVaultMaxNewBorrowWei;
+exports.eulerVaultMaxNewSupplyWei = eulerVaultMaxNewSupplyWei;
+exports.eulerWrappedGasTokenAliasesLower = eulerWrappedGasTokenAliasesLower;
+exports.fetchCoingeckoTokenUsdByContract = fetchCoingeckoTokenUsdByContract;
 exports.fetchEulerBorrowCollateralMaxWithdrawAssetsWei = fetchEulerBorrowCollateralMaxWithdrawAssetsWei;
+exports.fetchEulerLabelsEarnVaultAllowlist = fetchEulerLabelsEarnVaultAllowlist;
+exports.fetchEulerLabelsEntityNameByAddress = fetchEulerLabelsEntityNameByAddress;
+exports.fetchEulerLabelsVaultNameMap = fetchEulerLabelsVaultNameMap;
 exports.fetchEulerLendEarnVaultEffectiveMaxWithdrawWei = fetchEulerLendEarnVaultEffectiveMaxWithdrawWei;
+exports.fetchEulerReulVestingTranches = fetchEulerReulVestingTranches;
+exports.fetchEulerV2BorrowDebtWei = fetchEulerV2BorrowDebtWei;
+exports.fetchEulerV2BorrowOracleQuoteSnapshot = fetchEulerV2BorrowOracleQuoteSnapshot;
+exports.fetchEulerV2BorrowPairLtvs = fetchEulerV2BorrowPairLtvs;
+exports.fetchEulerV2ChainAssetCache = fetchEulerV2ChainAssetCache;
+exports.fetchEulerV2EarnOfferingsForRowAsset = fetchEulerV2EarnOfferingsForRowAsset;
+exports.fetchEulerV2IsolatedLendMarketsForRowAsset = fetchEulerV2IsolatedLendMarketsForRowAsset;
+exports.fetchEulerV2TrackingBorrowEntries = fetchEulerV2TrackingBorrowEntries;
+exports.fetchEulerV2TrackingDepositEntries = fetchEulerV2TrackingDepositEntries;
 exports.fetchEulerVaultAssetDecimals = fetchEulerVaultAssetDecimals;
 exports.fetchEulerVaultMaxWithdrawWei = fetchEulerVaultMaxWithdrawWei;
+exports.fetchEulerVaultOnChainLendMetrics = fetchEulerVaultOnChainLendMetrics;
+exports.fetchEulerVaultOnChainLendMetricsForVaults = fetchEulerVaultOnChainLendMetricsForVaults;
 exports.fetchEulerVaultUnderlyingMeta = fetchEulerVaultUnderlyingMeta;
+exports.flattenEulerV2BorrowCollateralRows = flattenEulerV2BorrowCollateralRows;
+exports.formatEulerRayApyPercent = formatEulerRayApyPercent;
+exports.formatEulerRaySupplyApyPercent = formatEulerRaySupplyApyPercent;
+exports.formatEulerResolvedCapOrCashForUi = formatEulerResolvedCapOrCashForUi;
+exports.loadEulerV2BorrowPositionsForOwner = loadEulerV2BorrowPositionsForOwner;
+exports.loadEulerV2LendSupplyPositionsForOwner = loadEulerV2LendSupplyPositionsForOwner;
+exports.loadEulerV2PortfolioUsdSnapshot = loadEulerV2PortfolioUsdSnapshot;
+exports.loadEulerV2SupportedChainIds = loadEulerV2SupportedChainIds;
+exports.maxCollateralWeiCappedByBorrowLiquidity = maxCollateralWeiCappedByBorrowLiquidity;
+exports.mergeEulerV2PositionsTabRows = mergeEulerV2PositionsTabRows;
+exports.parseEulerTrackingBorrowEntry = parseEulerTrackingBorrowEntry;
 exports.planSameAssetLeveragedBorrows = planSameAssetLeveragedBorrows;
+exports.resolveEulerAmountCapToSupplyWei = resolveEulerAmountCapToSupplyWei;
+exports.resolveEulerAmountCapToWei = resolveEulerAmountCapToWei;
+exports.resolveEulerWrappedNativeToken = resolveEulerWrappedNativeToken;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map