@continuumdao/ctm-mpc-defi 0.2.35 → 0.2.37

package/dist/protocols/evm/pendle/index.js

@@ -0,0 +1,1463 @@
+import { parseAbi, isAddress, getAddress, defineChain, createPublicClient, http, parseUnits, formatUnits, encodeFunctionData, parseGwei, serializeTransaction, keccak256 } from 'viem';
+import { fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+function matchesAssetFilter(opts) {
+  const f = (opts.filter ?? "").trim();
+  if (!f) return true;
+  const addr = (opts.address ?? "").trim();
+  if (isAddress(f) && isAddress(addr)) {
+    return getAddress(addr) === getAddress(f);
+  }
+  const sym = (opts.symbol ?? "").trim();
+  if (!sym) return false;
+  return sym.toLowerCase() === f.toLowerCase();
+}
+
+// src/protocols/evm/pendle/support.ts
+var PENDLE_PROTOCOL_ID = "pendle";
+var PENDLE_CORE_API_BASE = "https://api-v2.pendle.finance/core";
+var PENDLE_NATIVE_PLACEHOLDER = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+var PENDLE_LISTING_CAP = 100;
+var PENDLE_LISTING_MAX_PAGES = 8;
+var PENDLE_SEARCH_EXTRA_PAGES = 3;
+var PENDLE_ICON_CACHE_MS = 12 * 60 * 1e3;
+var PENDLE_CHAIN_CACHE_MS = 30 * 60 * 1e3;
+var PENDLE_CONVERT_DEFAULT_GAS_UNITS = 650000n;
+function parsePendleAssetId(id) {
+  const raw = (id ?? "").trim();
+  const dash = raw.indexOf("-");
+  if (dash <= 0) return null;
+  const chainId = Number.parseInt(raw.slice(0, dash), 10);
+  const address = raw.slice(dash + 1).trim();
+  if (!Number.isFinite(chainId) || chainId <= 0 || !address) return null;
+  return { chainId, address };
+}
+function pendleAssetId(chainId, address) {
+  return `${chainId}-${address.trim().toLowerCase()}`;
+}
+function isPendleNativeToken(token) {
+  const t = token.trim().toLowerCase();
+  return t === "eth" || t === "native" || t === PENDLE_NATIVE_PLACEHOLDER.toLowerCase() || t === "0x0000000000000000000000000000000000000000";
+}
+function normalizePendleTokenAddress(token) {
+  if (isPendleNativeToken(token)) return PENDLE_NATIVE_PLACEHOLDER.toLowerCase();
+  return token.trim().toLowerCase();
+}
+
+// src/protocols/evm/pendle/api.ts
+var FETCH_TIMEOUT_MS = 12e4;
+var PendleApiError = class extends Error {
+  status;
+  path;
+  constructor(message, status, path) {
+    super(message);
+    this.name = "PendleApiError";
+    this.status = status;
+    this.path = path;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function queryString(params) {
+  const q = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === "") continue;
+    q.set(k, String(v));
+  }
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
+async function pendleCoreFetch(args) {
+  const path = args.path.startsWith("/") ? args.path : `/${args.path}`;
+  const url = `${PENDLE_CORE_API_BASE}${path}${queryString(args.query ?? {})}`;
+  const headers = { Accept: "application/json" };
+  if (args.apiKey?.trim()) headers.Authorization = `Bearer ${args.apiKey.trim()}`;
+  if (args.body !== void 0) headers["Content-Type"] = "application/json";
+  let lastError;
+  for (let attempt = 0; attempt < 4; attempt++) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const res = await fetch(url, {
+        method: args.method ?? "GET",
+        headers,
+        body: args.body === void 0 ? void 0 : JSON.stringify(args.body),
+        signal: ac.signal
+      });
+      if (res.status === 429) {
+        const wait = Math.min(8e3, 500 * 2 ** attempt);
+        await sleep(wait);
+        lastError = new PendleApiError(`Pendle API rate limited (429) on ${path}`, 429, path);
+        continue;
+      }
+      const text = await res.text();
+      if (!res.ok) {
+        throw new PendleApiError(
+          `Pendle API ${res.status} ${path}: ${text.slice(0, 400)}`,
+          res.status,
+          path
+        );
+      }
+      if (!text.trim()) return {};
+      return JSON.parse(text);
+    } catch (err) {
+      lastError = err;
+      if (err instanceof PendleApiError && err.status !== 429) throw err;
+      if (attempt < 3 && (err instanceof PendleApiError || err?.name === "AbortError")) {
+        await sleep(Math.min(8e3, 400 * 2 ** attempt));
+        continue;
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+// src/protocols/evm/pendle/discover.ts
+var iconCacheByChain = /* @__PURE__ */ new Map();
+var marketsCacheByChain = /* @__PURE__ */ new Map();
+var chainIdsCache = null;
+function asRecord(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function asNumber(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim()) {
+    const n = Number.parseFloat(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function asString(v) {
+  if (typeof v === "string" && v.trim()) return v.trim();
+  return null;
+}
+function asExpiry(v) {
+  const s = asString(v);
+  if (s) return s;
+  const n = asNumber(v);
+  if (n == null) return null;
+  const ms = n < 1e12 ? n * 1e3 : n;
+  return new Date(ms).toISOString();
+}
+function pendleMarketExpiryMs(expiry) {
+  const raw = (expiry ?? "").trim();
+  if (!raw) return null;
+  if (/^\d+$/.test(raw)) {
+    const n = Number(raw);
+    return n < 1e12 ? n * 1e3 : n;
+  }
+  const t = Date.parse(raw);
+  return Number.isFinite(t) ? t : null;
+}
+function isPendleMarketExpired(row, nowMs = Date.now()) {
+  const t = pendleMarketExpiryMs(row.expiry);
+  if (t == null) return false;
+  return t <= nowMs;
+}
+function pendleActionNeedsLiveMarket(kind) {
+  return kind === "swap" || kind === "mintPy" || kind === "addLiquidity";
+}
+function marketMatchesPin(row, address) {
+  const a = address.trim().toLowerCase();
+  if (!a) return false;
+  return [row.address, row.pt, row.yt, row.sy].some((x) => x.toLowerCase() === a);
+}
+function selectPendleListingMarkets(rows, args = {}) {
+  const nowMs = args.nowMs ?? Date.now();
+  const cap = args.cap ?? PENDLE_LISTING_CAP;
+  const pins = (args.includeAddresses ?? []).map((a) => a.trim().toLowerCase()).filter(Boolean);
+  const q = (args.query ?? "").trim();
+  let out = rows.filter((r) => {
+    const pinned = pins.some((p) => marketMatchesPin(r, p));
+    if (!args.includeExpired && !pinned && isPendleMarketExpired(r, nowMs)) return false;
+    if (args.pointsOnly && r.points.length === 0) return false;
+    if (q && !marketMatchesQuery(r, q)) return false;
+    return true;
+  });
+  out.sort(sortPendleMarketsByTvl);
+  return out.slice(0, cap);
+}
+function addressFromAssetIdOrHex(raw, fallbackChainId) {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  const parsed = parsePendleAssetId(raw);
+  if (parsed) {
+    try {
+      return getAddress(parsed.address);
+    } catch {
+      return parsed.address.toLowerCase();
+    }
+  }
+  if (isAddress(raw)) return getAddress(raw);
+  if (raw.startsWith(`${fallbackChainId}-`)) {
+    const rest = raw.slice(String(fallbackChainId).length + 1);
+    if (isAddress(rest)) return getAddress(rest);
+  }
+  return null;
+}
+function parsePoints(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    const o = asRecord(item);
+    if (!o) continue;
+    const name = asString(o.name) ?? asString(o.key) ?? asString(o.pointName);
+    if (!name) continue;
+    out.push({
+      name,
+      type: asString(o.type),
+      pendleAsset: asString(o.pendleAsset),
+      value: asNumber(o.value)
+    });
+  }
+  return out;
+}
+function marketTvlUsd(row) {
+  return row.tvlUsd ?? row.liquidityUsd ?? 0;
+}
+function sortPendleMarketsByTvl(a, b) {
+  const d = marketTvlUsd(b) - marketTvlUsd(a);
+  if (d !== 0) return d;
+  return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+}
+function parsePendleMarket(raw) {
+  const o = asRecord(raw);
+  if (!o) return null;
+  const chainId = asNumber(o.chainId);
+  const address = addressFromAssetIdOrHex(o.address, chainId ?? 0);
+  if (chainId == null || !address) return null;
+  const details = asRecord(o.details);
+  const tvl = asNumber(o.tvl) ?? asNumber(details?.tvl) ?? asNumber(details?.totalTvl) ?? asNumber(asRecord(details?.liquidity)?.usd);
+  const liquidity = asNumber(o.liquidity) ?? asNumber(details?.liquidity) ?? asNumber(asRecord(details?.liquidity)?.usd);
+  const impliedApy = asNumber(o.impliedApy) ?? asNumber(details?.impliedApy) ?? asNumber(asRecord(o.pt)?.impliedApy);
+  const pt = addressFromAssetIdOrHex(o.pt ?? asRecord(o.pt)?.address ?? asRecord(o.pt)?.id, chainId);
+  const yt = addressFromAssetIdOrHex(o.yt ?? asRecord(o.yt)?.address ?? asRecord(o.yt)?.id, chainId);
+  const sy = addressFromAssetIdOrHex(o.sy ?? asRecord(o.sy)?.address ?? asRecord(o.sy)?.id, chainId);
+  const underlying = addressFromAssetIdOrHex(
+    o.underlyingAsset ?? o.underlying ?? asRecord(o.underlyingAsset)?.address,
+    chainId
+  );
+  if (!pt || !yt || !sy || !underlying) return null;
+  const expired = asExpiry(o.expiry) ?? asExpiry(details?.expiry);
+  return {
+    chainId,
+    name: asString(o.name) ?? asString(o.proSymbol) ?? `${address.slice(0, 8)}\u2026`,
+    address,
+    expiry: expired,
+    pt,
+    yt,
+    sy,
+    underlying,
+    underlyingSymbol: asString(asRecord(o.underlyingAsset)?.symbol) ?? asString(o.underlyingSymbol),
+    ptSymbol: asString(asRecord(o.pt)?.symbol) ?? asString(o.ptSymbol),
+    ytSymbol: asString(asRecord(o.yt)?.symbol) ?? asString(o.ytSymbol),
+    impliedApy,
+    tvlUsd: tvl,
+    liquidityUsd: liquidity,
+    points: parsePoints(o.points ?? details?.points)
+  };
+}
+function parsePendleAsset(raw) {
+  const o = asRecord(raw);
+  if (!o) return null;
+  const chainId = asNumber(o.chainId);
+  const address = addressFromAssetIdOrHex(o.address ?? o.id, chainId ?? 0);
+  if (chainId == null || !address) return null;
+  const decimals = asNumber(o.decimals);
+  return {
+    id: asString(o.id) ?? pendleAssetId(chainId, address),
+    chainId,
+    address,
+    symbol: asString(o.symbol) ?? "\u2014",
+    name: asString(o.name) ?? asString(o.symbol) ?? "\u2014",
+    decimals: decimals != null && decimals >= 0 ? Math.floor(decimals) : 18,
+    expiry: asString(o.expiry)
+  };
+}
+async function pendleFetchSupportedChainIds() {
+  const now = Date.now();
+  if (chainIdsCache && now - chainIdsCache.at < PENDLE_CHAIN_CACHE_MS) return chainIdsCache.chainIds;
+  const json = await pendleCoreFetch({ path: "/v1/chains" });
+  const ids = Array.isArray(json.chainIds) ? json.chainIds.map((n) => Number(n)).filter((n) => Number.isFinite(n) && n > 0) : [];
+  chainIdsCache = { at: now, chainIds: ids };
+  return ids;
+}
+async function isPendleChainSupported(chainId) {
+  try {
+    const ids = await pendleFetchSupportedChainIds();
+    if (ids.length === 0) return true;
+    return ids.includes(chainId);
+  } catch {
+    return true;
+  }
+}
+async function pendleFetchMarketsPage(args) {
+  const limit = Math.min(PENDLE_LISTING_CAP, Math.max(1, args.limit ?? PENDLE_LISTING_CAP));
+  const json = await pendleCoreFetch({
+    path: "/v2/markets/all",
+    query: {
+      skip: args.skip ?? 0,
+      limit,
+      ...args.chainId != null ? { chainId: args.chainId } : {}
+    }
+  });
+  const raw = Array.isArray(json.markets) ? json.markets : Array.isArray(json.results) ? json.results : [];
+  const rows = [];
+  for (const item of raw) {
+    const row = parsePendleMarket(item);
+    if (row) rows.push(row);
+  }
+  return rows;
+}
+async function pendleFetchMarketsForChain(chainId) {
+  const now = Date.now();
+  const cached = marketsCacheByChain.get(chainId);
+  if (cached && now - cached.at < PENDLE_ICON_CACHE_MS) return cached.rows;
+  const rows = [];
+  for (let page = 0; page < PENDLE_LISTING_MAX_PAGES; page++) {
+    const batch = await pendleFetchMarketsPage({
+      skip: page * PENDLE_LISTING_CAP,
+      limit: PENDLE_LISTING_CAP,
+      chainId
+    });
+    const onChain = batch.filter((r) => r.chainId === chainId);
+    rows.push(...onChain);
+    if (batch.length < PENDLE_LISTING_CAP || onChain.length === 0) break;
+  }
+  marketsCacheByChain.set(chainId, { at: now, rows });
+  return rows;
+}
+function marketMatchesQuery(row, query) {
+  const q = query.trim();
+  if (!q) return true;
+  if (matchesAssetFilter({ address: row.address, symbol: row.name, filter: q }) || matchesAssetFilter({ address: row.pt, symbol: row.ptSymbol ?? void 0, filter: q }) || matchesAssetFilter({ address: row.yt, symbol: row.ytSymbol ?? void 0, filter: q }) || matchesAssetFilter({ address: row.sy, filter: q }) || matchesAssetFilter({ address: row.underlying, symbol: row.underlyingSymbol ?? void 0, filter: q })) {
+    return true;
+  }
+  const hay = `${row.name} ${row.ptSymbol ?? ""} ${row.ytSymbol ?? ""} ${row.underlyingSymbol ?? ""}`.toLowerCase();
+  return hay.includes(q.toLowerCase());
+}
+async function pendleFetchMarketsSummary(args) {
+  if (!await isPendleChainSupported(args.chainId)) {
+    return {
+      chainId: args.chainId,
+      markets: [],
+      notes: `Pendle Core API does not list chain ${args.chainId}.`
+    };
+  }
+  const scanned = await pendleFetchMarketsForChain(args.chainId);
+  const rows = selectPendleListingMarkets(scanned, {
+    query: args.query,
+    pointsOnly: args.pointsOnly,
+    includeAddresses: args.includeAddresses
+  });
+  const expiredOmitted = scanned.filter((r) => isPendleMarketExpired(r)).length;
+  return {
+    chainId: args.chainId,
+    markets: rows,
+    notes: `Top ${rows.length} active Pendle markets on chain ${args.chainId} by TVL/liquidity (scanned ${scanned.length}, omitted ${expiredOmitted} matured). Use ctm_pendle_search_assets for long-tail or expired markets (PT redeem / remove LP). Do not web-search Pendle APYs.`
+  };
+}
+async function pendleFetchAssetsByIds(ids) {
+  if (ids.length === 0) return [];
+  const json = await pendleCoreFetch({
+    path: "/v1/assets/all",
+    query: { ids: ids.slice(0, 20).join(",") }
+  });
+  const raw = Array.isArray(json.assets) ? json.assets : [];
+  const out = [];
+  for (const item of raw) {
+    const row = parsePendleAsset(item);
+    if (row) out.push(row);
+  }
+  return out;
+}
+async function pendleFetchPricesSummary(args) {
+  let ids = (args.ids ?? []).map((s) => s.trim()).filter(Boolean);
+  if (ids.length === 0) {
+    const listed = await pendleFetchMarketsSummary({ chainId: args.chainId, query: args.query });
+    ids = listed.markets.flatMap((m) => [
+      pendleAssetId(m.chainId, m.pt),
+      pendleAssetId(m.chainId, m.yt),
+      pendleAssetId(m.chainId, m.sy),
+      pendleAssetId(m.chainId, m.address),
+      pendleAssetId(m.chainId, m.underlying)
+    ]);
+  }
+  if (ids.length === 0) {
+    return { chainId: args.chainId, prices: [], notes: "No asset ids to price." };
+  }
+  const json = await pendleCoreFetch({
+    path: "/v1/prices/assets",
+    query: { ids: ids.slice(0, 80).join(",") }
+  });
+  const prices = [];
+  const map = json.priceMap ?? {};
+  for (const id of ids.slice(0, 80)) {
+    const entry = map[id] ?? map[id.toLowerCase()];
+    if (typeof entry === "number") {
+      prices.push({ id, usd: Number.isFinite(entry) ? entry : null });
+    } else if (entry && typeof entry === "object") {
+      prices.push({ id, usd: asNumber(entry.usd ?? entry.price) });
+    } else {
+      prices.push({ id, usd: null });
+    }
+  }
+  return {
+    chainId: args.chainId,
+    prices,
+    notes: "USD prices from GET /v1/prices/assets for the current listing or supplied ids only."
+  };
+}
+function collectPendleMarketAddresses(row) {
+  return [row.address, row.pt, row.yt, row.sy, row.underlying].map((a) => a.toLowerCase());
+}
+async function pendleIconAddressesForChain(chainId) {
+  const now = Date.now();
+  const cached = iconCacheByChain.get(chainId);
+  if (cached && now - cached.at < PENDLE_ICON_CACHE_MS) return [...cached.addresses];
+  const addrs = /* @__PURE__ */ new Set();
+  const rows = await pendleFetchMarketsForChain(chainId);
+  for (const row of rows) {
+    for (const a of collectPendleMarketAddresses(row)) addrs.add(a);
+  }
+  try {
+    const pendleHits = await pendleSearchAssets({ chainId, query: "PENDLE" });
+    for (const row of pendleHits.results) {
+      for (const a of collectPendleMarketAddresses(row)) addrs.add(a);
+    }
+  } catch {
+  }
+  iconCacheByChain.set(chainId, { at: now, addresses: addrs });
+  return [...addrs];
+}
+async function pendleSearchAssets(args) {
+  const q = args.query.trim();
+  if (!q) throw new Error("query is required.");
+  if (!await isPendleChainSupported(args.chainId)) {
+    return { chainId: args.chainId, results: [], notes: `Pendle is not listed on chain ${args.chainId}.` };
+  }
+  const parsedId = parsePendleAssetId(q);
+  if (parsedId || isAddress(q)) {
+    const id = parsedId ? pendleAssetId(parsedId.chainId, parsedId.address) : pendleAssetId(args.chainId, q);
+    try {
+      const json = await pendleCoreFetch({
+        path: "/v1/markets/all",
+        query: { ids: id, chainId: args.chainId }
+      });
+      const raw = Array.isArray(json.markets) ? json.markets : [];
+      const exact = [];
+      for (const item of raw) {
+        const row = parsePendleMarket(item);
+        if (row && row.chainId === args.chainId) exact.push(row);
+      }
+      if (exact.length) {
+        exact.sort(sortPendleMarketsByTvl);
+        const live = exact.filter((r) => !isPendleMarketExpired(r));
+        if (live.length) {
+          return {
+            chainId: args.chainId,
+            results: live,
+            notes: "Exact market/asset id lookup via GET /v1/markets/all?ids= (active only)."
+          };
+        }
+        return {
+          chainId: args.chainId,
+          results: exact,
+          notes: "Exact market/asset id lookup \u2014 matured (redeem PT or remove LP only)."
+        };
+      }
+    } catch {
+    }
+  }
+  const scanned = await pendleFetchMarketsForChain(args.chainId);
+  const activeHits = selectPendleListingMarkets(scanned, { query: q });
+  if (activeHits.length > 0) {
+    return {
+      chainId: args.chainId,
+      results: activeHits,
+      notes: `Matched ${activeHits.length} active market(s) for ${q} on chain ${args.chainId}.`
+    };
+  }
+  const expiredHits = selectPendleListingMarkets(scanned, { query: q, includeExpired: true }).filter(
+    (r) => isPendleMarketExpired(r)
+  );
+  if (expiredHits.length > 0) {
+    return {
+      chainId: args.chainId,
+      results: expiredHits,
+      notes: `No live market matched ${q}. Showing ${expiredHits.length} matured market(s) (redeem PT or remove LP only \u2014 mint / YT swap / add LP will fail).`
+    };
+  }
+  return {
+    chainId: args.chainId,
+    results: [],
+    notes: `No Pendle market on chain ${args.chainId} matched ${q}.`
+  };
+}
+var erc20DecimalsAbi = parseAbi(["function decimals() view returns (uint8)"]);
+function asRecord2(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function asString2(v) {
+  return typeof v === "string" && v.trim() ? v.trim() : null;
+}
+function asNumber2(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim()) {
+    const n = Number.parseFloat(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function classifyPendleConvertAction(args) {
+  const norm = (s) => s.trim().toLowerCase();
+  const ins = args.tokensIn.map(norm);
+  const outs = args.tokensOut.map(norm);
+  const market = args.roles?.market?.trim().toLowerCase();
+  const pt = args.roles?.pt?.trim().toLowerCase();
+  const yt = args.roles?.yt?.trim().toLowerCase();
+  const sy = args.roles?.sy?.trim().toLowerCase();
+  if (market && ins.includes(market)) return "remove_liquidity";
+  if (market && outs.includes(market)) return "add_liquidity";
+  if (pt && yt && outs.includes(pt) && outs.includes(yt)) return "mint_py";
+  if (pt && yt && ins.includes(pt) && ins.includes(yt)) return "redeem_py";
+  if (sy && outs.includes(sy) && !ins.includes(sy)) return "mint_sy";
+  if (sy && ins.includes(sy) && !outs.includes(sy)) return "redeem_sy";
+  if (ins.length === 1 && outs.length === 1) return "swap";
+  return "convert";
+}
+function slippagePercentToConvert(slippagePercent) {
+  if (!Number.isFinite(slippagePercent) || slippagePercent <= 0 || slippagePercent >= 100) {
+    throw new Error("Slippage must be between 0 and 100 (exclusive).");
+  }
+  return slippagePercent / 100;
+}
+async function resolvePendleTokenDecimals(args) {
+  if (args.decimals != null && Number.isInteger(args.decimals) && args.decimals >= 0 && args.decimals <= 18) {
+    return args.decimals;
+  }
+  if (isPendleNativeToken(args.token)) return 18;
+  const id = pendleAssetId(args.chainId, normalizePendleTokenAddress(args.token));
+  try {
+    const assets = await pendleFetchAssetsByIds([id]);
+    if (assets[0]) return assets[0].decimals;
+  } catch {
+  }
+  if (!args.rpcUrl?.trim()) return 18;
+  const addr = getAddress(args.token);
+  const ch = defineChain({
+    id: args.chainId,
+    name: "PendleDecimals",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const client = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  const d = await client.readContract({ address: addr, abi: erc20DecimalsAbi, functionName: "decimals" });
+  return Number(d);
+}
+function parsePendleConvertResponse(raw) {
+  const root = asRecord2(raw);
+  if (!root) throw new Error("Pendle convert returned an empty body.");
+  const routes = Array.isArray(root.routes) ? root.routes : [];
+  const route = asRecord2(routes[0]) ?? root;
+  const txRaw = asRecord2(route.tx) ?? asRecord2(root.tx);
+  if (!txRaw) throw new Error("Pendle convert response missing routes[0].tx.");
+  const to = asString2(txRaw.to);
+  const data = asString2(txRaw.data);
+  if (!to || !data) throw new Error("Pendle convert tx is missing to/data. Use the API tx \u2014 do not hardcode a router.");
+  const dataHex = data.startsWith("0x") ? data : `0x${data}`;
+  const value = asString2(txRaw.value) ?? "0";
+  const dataObj = asRecord2(route.data) ?? asRecord2(root.data);
+  const implied = asRecord2(dataObj?.impliedApy);
+  const parseAmounts = (v) => {
+    if (!Array.isArray(v)) return [];
+    const out = [];
+    for (const item of v) {
+      const o = asRecord2(item);
+      const token = asString2(o?.token);
+      const amount = asString2(o?.amount);
+      if (token && amount) out.push({ token, amount });
+    }
+    return out;
+  };
+  return {
+    action: asString2(root.action) ?? asString2(route.action) ?? "convert",
+    inputs: parseAmounts(root.inputs ?? route.inputs),
+    outputs: parseAmounts(route.outputs ?? root.outputs),
+    requiredApprovals: parseAmounts(root.requiredApprovals ?? route.requiredApprovals),
+    priceImpact: asNumber2(dataObj?.priceImpact),
+    impliedApyBefore: asNumber2(implied?.before),
+    impliedApyAfter: asNumber2(implied?.after),
+    effectiveApy: asNumber2(dataObj?.effectiveApy),
+    tx: {
+      to: getAddress(to),
+      data: dataHex,
+      value,
+      from: asString2(txRaw.from) ?? void 0
+    }
+  };
+}
+async function pendleConvert(args) {
+  if (args.tokensIn.length === 0) throw new Error("tokensIn is required.");
+  if (args.tokensOut.length === 0) throw new Error("tokensOut is required.");
+  const receiver = getAddress(args.receiver);
+  const body = {
+    receiver,
+    slippage: slippagePercentToConvert(args.slippagePercent),
+    enableAggregator: args.enableAggregator === true,
+    inputs: args.tokensIn.map((t) => ({
+      token: normalizePendleTokenAddress(t.token),
+      amount: t.amountWei
+    })),
+    outputs: args.tokensOut.map((t) => normalizePendleTokenAddress(t)),
+    additionalData: args.additionalData ?? "impliedApy,effectiveApy"
+  };
+  const json = await pendleCoreFetch({
+    path: `/v3/sdk/${args.chainId}/convert`,
+    method: "POST",
+    body
+  });
+  return parsePendleConvertResponse(json);
+}
+async function pendleQuoteConvert(args) {
+  const receiver = args.receiver?.trim() || PENDLE_NATIVE_PLACEHOLDER;
+  const tokensIn = [];
+  for (const t of args.tokensIn) {
+    const decimals = await resolvePendleTokenDecimals({
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      token: t.token,
+      decimals: t.decimals
+    });
+    tokensIn.push({
+      token: t.token,
+      amountWei: parseUnits(t.amountHuman.trim(), decimals).toString()
+    });
+  }
+  return pendleConvert({
+    chainId: args.chainId,
+    receiver,
+    slippagePercent: args.slippagePercent,
+    tokensIn,
+    tokensOut: args.tokensOut,
+    enableAggregator: args.enableAggregator
+  });
+}
+async function pendleQuoteSwap(args) {
+  return pendleQuoteConvert({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    receiver: args.receiver,
+    slippagePercent: args.slippagePercent,
+    tokensIn: [{ token: args.tokenIn, amountHuman: args.amountHuman, decimals: args.tokenInDecimals }],
+    tokensOut: [args.tokenOut],
+    enableAggregator: args.enableAggregator
+  });
+}
+async function pendleQuoteMintPy(args) {
+  return pendleQuoteConvert({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    receiver: args.receiver,
+    slippagePercent: args.slippagePercent,
+    tokensIn: [{ token: args.tokenIn, amountHuman: args.amountHuman, decimals: args.tokenInDecimals }],
+    tokensOut: [args.pt, args.yt]
+  });
+}
+async function pendleQuoteRedeemPy(args) {
+  const tokensIn = [{ token: args.pt, amountHuman: args.amountPtHuman }];
+  const ytAmt = (args.amountYtHuman ?? args.amountPtHuman).trim();
+  if (ytAmt && ytAmt !== "0") tokensIn.push({ token: args.yt, amountHuman: ytAmt });
+  return pendleQuoteConvert({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    receiver: args.receiver,
+    slippagePercent: args.slippagePercent,
+    tokensIn,
+    tokensOut: [args.tokenOut]
+  });
+}
+async function pendleQuoteMintSy(args) {
+  return pendleQuoteConvert({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    receiver: args.receiver,
+    slippagePercent: args.slippagePercent,
+    tokensIn: [{ token: args.tokenIn, amountHuman: args.amountHuman }],
+    tokensOut: [args.sy]
+  });
+}
+async function pendleQuoteRedeemSy(args) {
+  return pendleQuoteConvert({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    receiver: args.receiver,
+    slippagePercent: args.slippagePercent,
+    tokensIn: [{ token: args.sy, amountHuman: args.amountHuman }],
+    tokensOut: [args.tokenOut]
+  });
+}
+async function pendleQuoteAddLiquidity(args) {
+  const tokensOut = [args.market];
+  if (args.keepYt) {
+    if (!args.yt?.trim()) throw new Error("yt is required for zero-price-impact (keep YT) add liquidity.");
+    tokensOut.push(args.yt);
+  }
+  return pendleQuoteConvert({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    receiver: args.receiver,
+    slippagePercent: args.slippagePercent,
+    tokensIn: args.tokensIn,
+    tokensOut
+  });
+}
+async function pendleQuoteRemoveLiquidity(args) {
+  return pendleQuoteConvert({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    receiver: args.receiver,
+    slippagePercent: args.slippagePercent,
+    tokensIn: [{ token: args.market, amountHuman: args.lpAmountHuman }],
+    tokensOut: args.tokensOut,
+    enableAggregator: args.enableAggregator
+  });
+}
+
+// src/protocols/evm/pendle/purpose.ts
+function buildPendlePurposePrefill(args) {
+  const act = (args.action || "convert").trim();
+  const detail = (args.detail || "").trim();
+  const slip = args.slippagePercent != null && Number.isFinite(args.slippagePercent) ? ` (max slippage ${args.slippagePercent}%)` : "";
+  return `Pendle: ${act} ${detail}${slip} on chain ${args.chainId}`;
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = (purposeText ?? "").trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload, (_, v) => typeof v === "bigint" ? v.toString() : v);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  if (input.expiryDate != null && input.expiryDate > 0) {
+    bodyForSign.expiryDate = Math.floor(input.expiryDate);
+  }
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpcUrl) });
+  const feeParams = await fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient.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 = getAddress(executorAddress);
+  const baseNonce = await publicClient.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 });
+    } else {
+      try {
+        estimatedGas = await publicClient.estimateGas({
+          to: step.to,
+          data: step.data,
+          value: step.value,
+          account: executor
+        });
+      } catch {
+        estimatedGas = step.fallbackGas ?? 100000n;
+      }
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = parseGwei(gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : parseGwei("1");
+      let maxFeePerGas = parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0,
+    expiryDate: context.expiryDate
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+
+// src/core/expiry.ts
+var DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS = 30 * 60;
+var DEFI_PROTOCOLS_WITH_30MIN_EXPIRY = /* @__PURE__ */ new Set([
+  "uniswap-v4",
+  "gmx",
+  "hyperliquid",
+  "arcus",
+  "curve-dao",
+  "aerodrome",
+  "pendle"
+]);
+function defiMultisignExpiryUnixSeconds(protocolId, explicitExpiryDate) {
+  if (typeof explicitExpiryDate === "number" && Number.isFinite(explicitExpiryDate) && explicitExpiryDate > 0) {
+    return Math.floor(explicitExpiryDate);
+  }
+  if (DEFI_PROTOCOLS_WITH_30MIN_EXPIRY.has(protocolId)) {
+    return Math.floor(Date.now() / 1e3) + DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS;
+  }
+  return void 0;
+}
+
+// src/protocols/evm/pendle/multisign.ts
+var erc20Abi = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)"
+]);
+function txValueWei(raw) {
+  try {
+    return BigInt(raw);
+  } catch {
+    return 0n;
+  }
+}
+async function approveStepsIfNeeded(args) {
+  const steps = [];
+  const ch = defineChain({
+    id: args.chainId,
+    name: "PendleApprove",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const client = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  for (const a of args.approvals) {
+    if (isPendleNativeToken(a.token)) continue;
+    const token = getAddress(a.token);
+    const amountWei = BigInt(a.amount);
+    const allowance = await client.readContract({
+      address: token,
+      abi: erc20Abi,
+      functionName: "allowance",
+      args: [args.owner, args.spender]
+    });
+    if (allowance >= amountWei) continue;
+    if (allowance > 0n) {
+      steps.push({
+        to: token,
+        data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [args.spender, 0n] }),
+        value: 0n,
+        kind: "approve",
+        fallbackGas: 80000n
+      });
+    }
+    steps.push({
+      to: token,
+      data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [args.spender, amountWei] }),
+      value: 0n,
+      kind: "approve",
+      fallbackGas: 80000n
+    });
+  }
+  return steps;
+}
+function isPendleConvertEvmSignRequest(extra) {
+  const evm = extra?.evm;
+  if (!evm || typeof evm !== "object" || Array.isArray(evm)) return false;
+  const t = String(evm.type ?? "");
+  return t.startsWith("pendle_");
+}
+async function buildEvmMultisignBodyPendleFromConvert(args) {
+  const executor = getAddress(args.executorAddress);
+  const spender = getAddress(args.quote.tx.to);
+  const steps = [
+    ...await approveStepsIfNeeded({
+      rpcUrl: args.rpcUrl,
+      chainId: args.chainId,
+      owner: executor,
+      spender,
+      approvals: args.quote.requiredApprovals
+    }),
+    {
+      to: spender,
+      data: args.quote.tx.data,
+      value: txValueWei(args.quote.tx.value),
+      kind: "convert",
+      routerSwap: true,
+      fallbackGas: PENDLE_CONVERT_DEFAULT_GAS_UNITS
+    }
+  ];
+  const expiryDate = defiMultisignExpiryUnixSeconds(PENDLE_PROTOCOL_ID, args.expiryDate);
+  const purposeText = args.purposeText.trim() || buildPendlePurposePrefill({
+    action: args.purposeAction,
+    detail: args.quote.action,
+    chainId: args.chainId
+  });
+  const chainGasLimitRouter = args.chainDetail?.gasLimit != null && Number.isFinite(Number(args.chainDetail.gasLimit)) && Number(args.chainDetail.gasLimit) > 0 ? Number(args.chainDetail.gasLimit) : void 0;
+  const first = steps[0];
+  const firstDataNo0x = first.data.startsWith("0x") ? first.data.slice(2) : first.data;
+  const payableValueWei = steps.reduce((a, s) => a + s.value, 0n);
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails,
+      expiryDate
+    },
+    steps,
+    purposeSuffix: steps.length === 1 ? `Pendle: ${args.purposeAction} via Hosted SDK convert.` : `Pendle: approve router from convert tx.to, then ${args.purposeAction}.`,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: first.to,
+    payableValueWei: payableValueWei > 0n ? payableValueWei : void 0,
+    resolveGasLimit: async ({ step, estimatedGas }) => {
+      const s = step;
+      if (s.routerSwap) return routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+      return estimatedGas;
+    },
+    buildBatchMeta: ({ step }) => {
+      const s = step;
+      return {
+        evm: {
+          type: s.kind === "approve" ? "pendle_approve" : `pendle_${args.purposeAction.replace(/\s+/g, "_")}`,
+          version: 1,
+          chainId: String(args.chainId),
+          convertAction: args.quote.action
+        }
+      };
+    }
+  });
+}
+async function buildEvmMultisignBodyPendleSwapBatch(args) {
+  const quote = args.convertSnapshot ?? await pendleQuoteSwap({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    tokenIn: args.tokenIn,
+    tokenOut: args.tokenOut,
+    amountHuman: args.amountHuman,
+    slippagePercent: args.slippagePercent,
+    receiver: String(args.executorAddress),
+    enableAggregator: args.enableAggregator,
+    tokenInDecimals: args.tokenInDecimals
+  });
+  return buildEvmMultisignBodyPendleFromConvert({ ...args, quote, purposeAction: "swap" });
+}
+async function buildEvmMultisignBodyPendleMintPyBatch(args) {
+  const quote = args.convertSnapshot ?? await pendleQuoteMintPy({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    tokenIn: args.tokenIn,
+    pt: args.pt,
+    yt: args.yt,
+    amountHuman: args.amountHuman,
+    slippagePercent: args.slippagePercent,
+    receiver: String(args.executorAddress),
+    tokenInDecimals: args.tokenInDecimals
+  });
+  return buildEvmMultisignBodyPendleFromConvert({ ...args, quote, purposeAction: "mint_py" });
+}
+async function buildEvmMultisignBodyPendleRedeemPyBatch(args) {
+  const quote = args.convertSnapshot ?? await pendleQuoteRedeemPy({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    pt: args.pt,
+    yt: args.yt,
+    tokenOut: args.tokenOut,
+    amountPtHuman: args.amountPtHuman,
+    amountYtHuman: args.amountYtHuman,
+    slippagePercent: args.slippagePercent,
+    receiver: String(args.executorAddress)
+  });
+  return buildEvmMultisignBodyPendleFromConvert({ ...args, quote, purposeAction: "redeem_py" });
+}
+async function buildEvmMultisignBodyPendleMintSyBatch(args) {
+  const quote = args.convertSnapshot ?? await pendleQuoteMintSy({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    tokenIn: args.tokenIn,
+    sy: args.sy,
+    amountHuman: args.amountHuman,
+    slippagePercent: args.slippagePercent,
+    receiver: String(args.executorAddress)
+  });
+  return buildEvmMultisignBodyPendleFromConvert({ ...args, quote, purposeAction: "mint_sy" });
+}
+async function buildEvmMultisignBodyPendleRedeemSyBatch(args) {
+  const quote = args.convertSnapshot ?? await pendleQuoteRedeemSy({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    sy: args.sy,
+    tokenOut: args.tokenOut,
+    amountHuman: args.amountHuman,
+    slippagePercent: args.slippagePercent,
+    receiver: String(args.executorAddress)
+  });
+  return buildEvmMultisignBodyPendleFromConvert({ ...args, quote, purposeAction: "redeem_sy" });
+}
+async function buildEvmMultisignBodyPendleAddLiquidityBatch(args) {
+  const quote = args.convertSnapshot ?? await pendleQuoteAddLiquidity({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    tokensIn: args.tokensIn,
+    market: args.market,
+    keepYt: args.keepYt,
+    yt: args.yt,
+    slippagePercent: args.slippagePercent,
+    receiver: String(args.executorAddress)
+  });
+  return buildEvmMultisignBodyPendleFromConvert({ ...args, quote, purposeAction: "add_liquidity" });
+}
+async function buildEvmMultisignBodyPendleRemoveLiquidityBatch(args) {
+  const quote = args.convertSnapshot ?? await pendleQuoteRemoveLiquidity({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    market: args.market,
+    lpAmountHuman: args.lpAmountHuman,
+    tokensOut: args.tokensOut,
+    slippagePercent: args.slippagePercent,
+    receiver: String(args.executorAddress),
+    enableAggregator: args.enableAggregator
+  });
+  return buildEvmMultisignBodyPendleFromConvert({ ...args, quote, purposeAction: "remove_liquidity" });
+}
+async function buildEvmMultisignBodyPendleConvertBatch(args) {
+  const quote = args.convertSnapshot ?? await pendleQuoteConvert({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    receiver: String(args.executorAddress),
+    slippagePercent: args.slippagePercent,
+    tokensIn: args.tokensIn,
+    tokensOut: args.tokensOut,
+    enableAggregator: args.enableAggregator
+  });
+  return buildEvmMultisignBodyPendleFromConvert({ ...args, quote, purposeAction: quote.action });
+}
+function asRecord3(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function parsePendleMerkleRewardRow(raw) {
+  const o = asRecord3(raw);
+  if (!o) return null;
+  const token = typeof o.token === "string" ? o.token : "";
+  const chainId = Number(o.chainId);
+  if (!token || !Number.isFinite(chainId)) return null;
+  return {
+    user: typeof o.user === "string" ? o.user : "",
+    token,
+    merkleRoot: typeof o.merkleRoot === "string" ? o.merkleRoot : "",
+    chainId,
+    assetId: typeof o.assetId === "string" ? o.assetId : "",
+    amount: String(o.amount ?? ""),
+    fromTimestamp: typeof o.fromTimestamp === "string" ? o.fromTimestamp : null,
+    toTimestamp: typeof o.toTimestamp === "string" ? o.toTimestamp : null
+  };
+}
+async function pendleFetchMerkleRewards(args) {
+  if (!isAddress(args.user)) throw new Error("user must be an EVM address.");
+  const user = getAddress(args.user);
+  const json = await pendleCoreFetch({
+    path: `/v1/dashboard/merkle-rewards/${user}`
+  });
+  const claimable = Array.isArray(json.claimableRewards) ? json.claimableRewards.map(parsePendleMerkleRewardRow).filter((r) => r != null) : [];
+  const claimed = Array.isArray(json.claimedRewards) ? json.claimedRewards.map(parsePendleMerkleRewardRow).filter((r) => r != null) : [];
+  return {
+    user,
+    claimableRewards: claimable,
+    claimedRewards: claimed,
+    notes: "Informational airdrop list only. Core does not include claim proofs. Tell the user to claim airdrops on app.pendle.finance. Redeem on-chain SY/YT/LP incentives with ctm_pendle_build_redeem_rewards_multisign."
+  };
+}
+function asRecord4(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function asNumber3(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim()) {
+    const n = Number.parseFloat(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function weiToHumanAmount(wei, decimals) {
+  try {
+    const raw = formatUnits(BigInt(wei), decimals);
+    if (!raw.includes(".")) return raw;
+    return raw.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
+  } catch {
+    return wei;
+  }
+}
+function parsePendlePositionToken(raw) {
+  const o = asRecord4(raw);
+  if (!o) return { balanceWei: "0", usd: null };
+  const balance = o.balance == null ? "0" : String(o.balance);
+  return { balanceWei: /^\d+$/.test(balance) ? balance : "0", usd: asNumber3(o.valuation) };
+}
+function positiveWei(wei) {
+  try {
+    return BigInt(wei) > 0n;
+  } catch {
+    return false;
+  }
+}
+function collectPendleMarketPositions(raw, closed) {
+  const o = asRecord4(raw);
+  if (!o) return [];
+  const marketId = typeof o.marketId === "string" ? o.marketId : "";
+  const parsed = parsePendleAssetId(marketId);
+  if (!parsed) return [];
+  let market;
+  try {
+    market = getAddress(parsed.address);
+  } catch {
+    return [];
+  }
+  const lp = parsePendlePositionToken(o.lp);
+  if (!positiveWei(lp.balanceWei)) return [];
+  return [
+    {
+      marketId,
+      chainId: parsed.chainId,
+      market,
+      closed,
+      lp,
+      pt: parsePendlePositionToken(o.pt),
+      yt: parsePendlePositionToken(o.yt)
+    }
+  ];
+}
+async function assetsByIds(ids) {
+  const out = /* @__PURE__ */ new Map();
+  const unique = [...new Set(ids.map((id) => id.trim()).filter(Boolean))];
+  for (let i = 0; i < unique.length; i += 20) {
+    const batch = await pendleFetchAssetsByIds(unique.slice(i, i + 20));
+    for (const row of batch) out.set(row.id.toLowerCase(), row);
+  }
+  return out;
+}
+async function pendleFetchPositions(args) {
+  if (!isAddress(args.user)) throw new Error("user must be an EVM address.");
+  const user = getAddress(args.user);
+  const chainId = args.chainId != null && Number.isFinite(args.chainId) ? args.chainId : void 0;
+  const json = await pendleCoreFetch({
+    path: `/v1/dashboard/positions/database/${user}`,
+    query: {
+      ...chainId != null ? { chainId } : {},
+      ...args.filterUsd != null ? { filterUsd: args.filterUsd } : {}
+    }
+  });
+  const groups = Array.isArray(json.positions) ? json.positions : [];
+  const collected = [];
+  for (const group of groups) {
+    const g = asRecord4(group);
+    if (!g) continue;
+    const groupChain = asNumber3(g.chainId);
+    if (chainId != null && groupChain != null && groupChain !== chainId) continue;
+    for (const row of Array.isArray(g.openPositions) ? g.openPositions : []) {
+      collected.push(...collectPendleMarketPositions(row, false));
+    }
+    for (const row of Array.isArray(g.closedPositions) ? g.closedPositions : []) {
+      collected.push(...collectPendleMarketPositions(row, true));
+    }
+  }
+  const scoped = (chainId != null ? collected.filter((r) => r.chainId === chainId) : collected).filter((r) => {
+    if (args.filterUsd != null && r.lp.usd != null && r.lp.usd < args.filterUsd) return false;
+    try {
+      return BigInt(r.lp.balanceWei) >= 10n ** 12n || r.lp.usd != null && r.lp.usd >= (args.filterUsd ?? 0.1);
+    } catch {
+      return false;
+    }
+  });
+  const meta = await assetsByIds(scoped.map((r) => r.marketId));
+  const minUsd = args.filterUsd;
+  const lp = [];
+  for (const row of scoped) {
+    const asset = meta.get(row.marketId.toLowerCase());
+    const decimals = asset?.decimals ?? 18;
+    const expiry = asset?.expiry ?? null;
+    const usd = row.lp.usd;
+    if (minUsd != null && (usd == null || usd < minUsd)) continue;
+    lp.push({
+      chainId: row.chainId,
+      marketId: row.marketId,
+      market: row.market,
+      name: asset?.name || asset?.symbol || `${row.market.slice(0, 8)}\u2026`,
+      symbol: asset?.symbol || "LP",
+      decimals,
+      expiry,
+      matured: isPendleMarketExpired({ expiry }),
+      closed: row.closed,
+      lpBalanceWei: row.lp.balanceWei,
+      lpAmountHuman: weiToHumanAmount(row.lp.balanceWei, decimals),
+      lpUsd: usd,
+      ptBalanceWei: row.pt.balanceWei,
+      ytBalanceWei: row.yt.balanceWei
+    });
+  }
+  lp.sort((a, b) => {
+    if (a.matured !== b.matured) return a.matured ? 1 : -1;
+    return (b.lpUsd ?? 0) - (a.lpUsd ?? 0);
+  });
+  const capped = lp.slice(0, 80);
+  const matured = capped.filter((r) => r.matured).length;
+  return {
+    user,
+    chainId: chainId ?? null,
+    lp: capped,
+    notes: capped.length === 0 ? `No Pendle LP for ${user}${chainId != null ? ` on chain ${chainId}` : ""}.` : `${capped.length} Pendle LP holding(s)${chainId != null ? ` on chain ${chainId}` : ""}` + (lp.length > capped.length ? ` (showing top ${capped.length} of ${lp.length})` : "") + (matured ? ` (${matured} matured \u2014 remove LP or redeem PT only)` : "") + ". Amounts from Core dashboard (not the node token list). Claimable rewards on this snapshot may be up to 24h stale \u2014 redeem with ctm_pendle_build_redeem_rewards_multisign."
+  };
+}
+async function pendleRedeemInterestsAndRewards(args) {
+  const receiver = getAddress(args.receiver);
+  const json = await pendleCoreFetch({
+    path: `/v1/sdk/${args.chainId}/redeem-interests-and-rewards`,
+    query: {
+      receiver,
+      sys: args.sys?.length ? args.sys.join(",") : void 0,
+      yts: args.yts?.length ? args.yts.join(",") : void 0,
+      markets: args.markets?.length ? args.markets.join(",") : void 0
+    }
+  });
+  return parsePendleConvertResponse(json);
+}
+async function buildEvmMultisignBodyPendleRedeemRewardsBatch(args) {
+  const quote = args.convertSnapshot ?? await pendleRedeemInterestsAndRewards({
+    chainId: args.chainId,
+    receiver: String(args.executorAddress),
+    sys: args.sys,
+    yts: args.yts,
+    markets: args.markets
+  });
+  return buildEvmMultisignBodyPendleFromConvert({
+    ...args,
+    quote,
+    purposeAction: "redeem_rewards"
+  });
+}
+
+// src/protocols/evm/pendle/index.ts
+var pendleProtocolModule = {
+  id: PENDLE_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const n = typeof ctx.chainId === "number" ? ctx.chainId : Number.parseInt(String(ctx.chainId), 10);
+    if (!Number.isFinite(n)) return false;
+    return isPendleChainSupported(n);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "native" || token.kind === "erc20";
+  },
+  actions: [
+    { id: "pendle.fetch-markets", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "List live Pendle markets (TVL-ranked, cap 100, matured omitted)", commonParams: [], params: {} },
+    { id: "pendle.search-assets", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Search live PT/YT/SY/underlying (matured only if address-pinned)", commonParams: [], params: {} },
+    { id: "pendle.swap", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Swap token \u2194 PT/YT via Hosted SDK convert", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.mint-py", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Mint PT + YT", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.redeem-py", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Redeem PT + YT (PT only after expiry)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.add-liquidity", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Add Pendle AMM liquidity", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.fetch-positions", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "List this wallet\u2019s Pendle LP (including matured)", commonParams: [], params: {} },
+    { id: "pendle.remove-liquidity", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Remove Pendle AMM liquidity", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.redeem-rewards", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Redeem on-chain SY/YT/LP interest and incentives (not merkle airdrops)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(pendleProtocolModule);
+
+export { PENDLE_CHAIN_CACHE_MS, PENDLE_CONVERT_DEFAULT_GAS_UNITS, PENDLE_CORE_API_BASE, PENDLE_ICON_CACHE_MS, PENDLE_LISTING_CAP, PENDLE_LISTING_MAX_PAGES, PENDLE_NATIVE_PLACEHOLDER, PENDLE_PROTOCOL_ID, PENDLE_SEARCH_EXTRA_PAGES, PendleApiError, buildEvmMultisignBodyPendleAddLiquidityBatch, buildEvmMultisignBodyPendleConvertBatch, buildEvmMultisignBodyPendleFromConvert, buildEvmMultisignBodyPendleMintPyBatch, buildEvmMultisignBodyPendleMintSyBatch, buildEvmMultisignBodyPendleRedeemPyBatch, buildEvmMultisignBodyPendleRedeemRewardsBatch, buildEvmMultisignBodyPendleRedeemSyBatch, buildEvmMultisignBodyPendleRemoveLiquidityBatch, buildEvmMultisignBodyPendleSwapBatch, buildPendlePurposePrefill, classifyPendleConvertAction, collectPendleMarketAddresses, collectPendleMarketPositions, isPendleChainSupported, isPendleConvertEvmSignRequest, isPendleMarketExpired, isPendleNativeToken, marketTvlUsd, normalizePendleTokenAddress, parsePendleAsset, parsePendleAssetId, parsePendleConvertResponse, parsePendleMarket, parsePendleMerkleRewardRow, parsePendlePositionToken, pendleActionNeedsLiveMarket, pendleAssetId, pendleConvert, pendleCoreFetch, pendleFetchAssetsByIds, pendleFetchMarketsForChain, pendleFetchMarketsPage, pendleFetchMarketsSummary, pendleFetchMerkleRewards, pendleFetchPositions, pendleFetchPricesSummary, pendleFetchSupportedChainIds, pendleIconAddressesForChain, pendleMarketExpiryMs, pendleProtocolModule, pendleQuoteAddLiquidity, pendleQuoteConvert, pendleQuoteMintPy, pendleQuoteMintSy, pendleQuoteRedeemPy, pendleQuoteRedeemSy, pendleQuoteRemoveLiquidity, pendleQuoteSwap, pendleRedeemInterestsAndRewards, pendleSearchAssets, resolvePendleTokenDecimals, selectPendleListingMarkets, slippagePercentToConvert, sortPendleMarketsByTvl, weiToHumanAmount };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map