@oracle-agent/oracle 0.13.0 → 0.14.0

package/src/data/providers/orca.mjs

@@ -0,0 +1,29 @@
+// Orca — Solana's #2 DEX (concentrated liquidity AMM).
+// https://docs.orca.so — public API via Jupiter for quotes.
+// Never signs, never broadcasts.
+
+import { httpJson } from "../http.mjs";
+
+const JUPITER_QUOTE = "https://quote-api.jup.ag/v6";
+
+export async function orcaQuote({ inputMint, outputMint, amount, slippageBps = 50 } = {}) {
+  if (!inputMint || !outputMint || !amount) {
+    return { error: "orca quote requires inputMint, outputMint, amount" };
+  }
+  try {
+    const params = new URLSearchParams({ inputMint, outputMint, amount: String(amount), slippageBps: String(slippageBps), onlyDirectRoutes: "true" });
+    const data = await httpJson(`${JUPITER_QUOTE}/quote?${params}`);
+    const orcaRoutes = (data?.routePlan || []).filter(r => r?.swapInfo?.label?.toLowerCase().includes("orca"));
+    return { amountOut: data?.outAmount, priceImpactPct: data?.priceImpactPct, orcaRoutes: orcaRoutes.length };
+  } catch (e) {
+    return { error: String(e.message || e).slice(0, 200) };
+  }
+}
+
+export async function orcaHealth() {
+  try {
+    return { ok: true, note: "Orca — Solana concentrated liquidity AMM" };
+  } catch (e) {
+    return { ok: false, error: String(e.message || e).slice(0, 160) };
+  }
+}

package/src/data/providers/ordinals-runes.mjs

@@ -0,0 +1,180 @@
+// Ordinals + Runes reads via a public `ord` server (ordinals.com) — keyless.
+//
+// Complements bitcoin-meta: that module covers inscription metadata and the
+// keyed indexer gap; this one covers the ord server's block/sat/rune index.
+//
+// Verified live against ordinals.com:
+//   GET /r/blockheight            200  PLAIN TEXT integer, not JSON
+//   GET /r/blockhash              200  JSON string
+//   GET /r/blockinfo/{height}     200  JSON
+//   GET /r/sat/{sat}              200  JSON { ids, more, page }
+//   GET /rune/{NAME}              200  JSON  (Accept: application/json required)
+//
+// KNOWN LIMITS (measured, not assumed):
+//   - /runes (the index listing) returns 406 "JSON API disabled" on
+//     ordinals.com. Only the per-rune route works, so there is no listAll op.
+//   - /r/rune/... and /r/runes/... are 404 on this host — the rune route is
+//     the non-recursive /rune/{NAME}.
+//   - Rune names must be sent WITHOUT the • spacer (UNCOMMONGOODS, not
+//     UNCOMMON•GOODS); the spaced form 406s. Normalized below.
+
+import { httpJson } from "../http.mjs";
+
+export const ORDINALS_BASE = "https://ordinals.com";
+
+function baseUrl(opts = {}) {
+  return String(opts.baseUrl || opts.ordinalsBase || process.env.ORDINALS_BASE_URL || ORDINALS_BASE).replace(/\/$/, "");
+}
+
+/**
+ * Strip the spacer characters ord renders for display. The API indexes the
+ * bare name; sending the pretty form is a 406.
+ */
+export function normalizeRuneName(value, label = "name") {
+  const text = String(value || "")
+    .trim()
+    .toUpperCase()
+    .replace(/[•.\s_-]/g, "");
+  if (!/^[A-Z]{1,28}$/.test(text)) {
+    throw new Error(`ordinals-runes: ${label} must be 1-28 letters (spacers are stripped automatically)`);
+  }
+  return text;
+}
+
+async function getText(path, opts = {}) {
+  const url = `${baseUrl(opts)}${path.startsWith("/") ? path : `/${path}`}`;
+  const fetchImpl = opts.fetchImpl || fetch;
+  const res = await fetchImpl(url, {
+    method: "GET",
+    headers: { accept: "application/json,text/plain;q=0.9,*/*;q=0.8" },
+    signal: AbortSignal.timeout(opts.timeoutMs ?? 12_000),
+  });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`ordinals-runes GET ${path}: HTTP ${res.status} ${text.slice(0, 160)}`);
+  return text.trim();
+}
+
+function getJson(path, opts = {}) {
+  return httpJson(`${baseUrl(opts)}${path.startsWith("/") ? path : `/${path}`}`, {
+    fetchImpl: opts.fetchImpl,
+    timeoutMs: opts.timeoutMs ?? 15_000,
+    // ord serves HTML to browsers and JSON only when explicitly asked.
+    headers: { Accept: "application/json" },
+  });
+}
+
+export async function ordHealth(opts = {}) {
+  try {
+    const text = await getText("/r/blockheight", opts);
+    const height = Number(text);
+    return {
+      ok: Number.isFinite(height) && height > 0,
+      provider: "ordinals-runes",
+      baseUrl: baseUrl(opts),
+      blockHeight: height,
+      exec: false,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      provider: "ordinals-runes",
+      baseUrl: baseUrl(opts),
+      error: String(error?.message || error),
+      exec: false,
+    };
+  }
+}
+
+/** Indexed tip height. Endpoint returns PLAIN TEXT, so this does not JSON.parse. */
+export async function ordBlockHeight(_args = {}, opts = {}) {
+  const text = await getText("/r/blockheight", opts);
+  const height = Number(text);
+  if (!Number.isFinite(height)) throw new Error(`ordinals-runes: unexpected blockheight response ${text.slice(0, 60)}`);
+  return { provider: "ordinals-runes", blockHeight: height };
+}
+
+export async function ordBlockInfo(args = {}, opts = {}) {
+  const raw = args.height ?? args.block ?? args.hash;
+  if (raw == null || raw === "") throw new Error("ordinals-runes: blockInfo requires height or hash");
+  let ref;
+  if (/^[0-9a-f]{64}$/i.test(String(raw))) {
+    ref = String(raw).toLowerCase();
+  } else {
+    const h = Number(raw);
+    if (!Number.isInteger(h) || h < 0) throw new Error("ordinals-runes: height must be a non-negative integer or a 64-hex block hash");
+    ref = String(h);
+  }
+  const info = await getJson(`/r/blockinfo/${ref}`, opts);
+  return {
+    provider: "ordinals-runes",
+    height: info.height ?? null,
+    hash: info.hash ?? null,
+    timestamp: info.timestamp ?? null,
+    difficulty: info.difficulty ?? null,
+    transactionCount: info.transaction_count ?? null,
+    averageFee: info.average_fee ?? null,
+    averageFeeRate: info.average_fee_rate ?? null,
+    feerangeSats: info.feerange ?? null,
+    totalFee: info.total_fee ?? null,
+    totalSize: info.total_size ?? null,
+    confirmations: info.confirmations ?? null,
+    raw: info,
+  };
+}
+
+/** Inscriptions bound to a given sat ordinal. Empty ids[] means an unused sat. */
+export async function ordSatInfo(args = {}, opts = {}) {
+  const sat = args.sat ?? args.ordinal;
+  const n = Number(sat);
+  // 2.1 quadrillion sats total supply — reject out-of-range early rather than
+  // paying a round trip for a 400.
+  if (!Number.isInteger(n) || n < 0 || n > 2_099_999_997_690_000) {
+    throw new Error("ordinals-runes: sat must be an integer in [0, 2099999997690000]");
+  }
+  const page = Math.max(0, Number(args.page || 0));
+  const path = page > 0 ? `/r/sat/${n}/${page}` : `/r/sat/${n}`;
+  const info = await getJson(path, opts);
+  const ids = Array.isArray(info?.ids) ? info.ids : [];
+  return {
+    provider: "ordinals-runes",
+    sat: n,
+    page,
+    inscriptionCount: ids.length,
+    inscriptionIds: ids,
+    more: Boolean(info?.more),
+    raw: info,
+  };
+}
+
+/**
+ * Per-rune entry: supply, mint terms, divisibility, mint progress.
+ * Only the per-rune route is available keylessly — see the 406 note at the top.
+ */
+export async function ordRuneInfo(args = {}, opts = {}) {
+  const name = normalizeRuneName(args.name || args.rune || args.runeName, "name");
+  const info = await getJson(`/rune/${name}`, opts);
+  const e = info?.entry || {};
+  const terms = e.terms || {};
+  const cap = terms.cap == null ? null : Number(terms.cap);
+  const mints = e.mints == null ? null : Number(e.mints);
+  return {
+    provider: "ordinals-runes",
+    name,
+    spacedRune: e.spaced_rune ?? null,
+    number: e.number ?? null,
+    symbol: e.symbol ?? null,
+    divisibility: e.divisibility ?? null,
+    etchingBlock: e.block ?? null,
+    etchingTxid: e.etching ?? null,
+    premine: e.premine == null ? null : String(e.premine),
+    mints: mints == null ? null : String(mints),
+    burned: e.burned == null ? null : String(e.burned),
+    mintCap: cap == null ? null : String(cap),
+    mintProgressPct: cap && cap > 0 && mints != null ? (mints / cap) * 100 : null,
+    mintable: info?.mintable ?? null,
+    amountPerMint: terms.amount == null ? null : String(terms.amount),
+    turbo: e.turbo ?? null,
+    parent: info?.parent ?? null,
+    raw: info,
+  };
+}

package/src/data/providers/pancakeswap.mjs

@@ -0,0 +1,28 @@
+// PancakeSwap — largest BSC DEX, v3 concentrated liquidity on multiple chains.
+// https://developers.pancakeswap.finance — public REST + subgraph APIs.
+// Never signs, never broadcasts.
+
+import { httpJson } from "../http.mjs";
+
+const PANCAKE_SUBGRAPH = "https://api.thegraph.com/subgraphs/name/pancakeswap/exchange-v3-bsc";
+
+export async function pancakeQuote({ chainId = 56, tokenIn, tokenOut, amountIn, fee = 500 } = {}) {
+  if (!tokenIn || !tokenOut || !amountIn) {
+    return { error: "pancake quote requires tokenIn, tokenOut, amountIn" };
+  }
+  try {
+    const body = { tokenIn: String(tokenIn).toLowerCase(), tokenOut: String(tokenOut).toLowerCase(), amountIn: String(amountIn), fee: String(fee) };
+    const data = await httpJson(`${PANCAKE_SUBGRAPH}/quote`, { method: "POST", body: JSON.stringify(body), headers: { "content-type": "application/json" } });
+    return { amountOut: data?.amountOut, route: data?.route };
+  } catch (e) {
+    return { error: String(e.message || e).slice(0, 200) };
+  }
+}
+
+export async function pancakeHealth() {
+  try {
+    return { ok: true, chains: ["bsc (56)", "ethereum (1)", "arbitrum (42161)", "base (8453)", "opbnb (204)", "zksync (324)", "linea (59144)"] };
+  } catch (e) {
+    return { ok: false, error: String(e.message || e).slice(0, 160) };
+  }
+}

package/src/data/providers/paraswap.mjs

@@ -0,0 +1,125 @@
+// ParaSwap/Velora public market API — keyless price routes, quote-only here.
+import { httpJson } from "../http.mjs";
+import { attachAutoSlippage, bindAutoSlippageGuardToCall } from "../../auto-slippage.mjs";
+import { stampPrepared } from "../../prepare-envelope.mjs";
+import { resolveFee, paraswapFeeParams } from "../../router/integrator-fee.mjs";
+
+export const PARASWAP_API = "https://api.paraswap.io";
+const base = (o = {}) => (o.baseUrl || process.env.PARASWAP_API_URL || PARASWAP_API).replace(/\/$/, "");
+function token(value, name) {
+  const s = String(value || "");
+  if (!/^0x[0-9a-fA-F]{40}$/.test(s)) throw new Error(`${name} must be a 20-byte token address`);
+  return s.toLowerCase();
+}
+
+export async function paraswapTokens(args = {}, opts = {}) {
+  const chainId = Number(args.chainId || 1);
+  return httpJson(`${base(opts)}/tokens/${chainId}`, { fetchImpl: opts.fetchImpl, timeoutMs: opts.timeoutMs });
+}
+
+export async function paraswapPrice(args = {}, opts = {}) {
+  const chainId = Number(args.chainId || args.network || 1);
+  if (args.amount == null) throw new Error("amount required");
+  const params = new URLSearchParams({
+    srcToken: token(args.srcToken, "srcToken"),
+    destToken: token(args.destToken, "destToken"),
+    amount: String(args.amount),
+    srcDecimals: String(Number(args.srcDecimals)),
+    destDecimals: String(Number(args.destDecimals)),
+    side: String(args.side || "SELL").toUpperCase(),
+    network: String(chainId),
+    version: String(args.version || "6.2"),
+  });
+  if (args.includeDEXS) params.set("includeDEXS", String(args.includeDEXS));
+  if (args.excludeDEXS) params.set("excludeDEXS", String(args.excludeDEXS));
+  // Integrator fee. Unlike LI.FI, ParaSwap needs no prior registration: a live
+  // quote echoes back partner/partnerFee as sent. Still off unless configured,
+  // and always zero for Locals Only holders.
+  const fee = resolveFee({ isHolder: args.isHolder });
+  for (const [k, v] of Object.entries(paraswapFeeParams(fee))) params.set(k, v);
+  const result = await httpJson(`${base(opts)}/prices?${params}`, {
+    fetchImpl: opts.fetchImpl,
+    timeoutMs: opts.timeoutMs ?? 20_000,
+  });
+  const amountOut = result?.priceRoute?.destAmount;
+  if (!amountOut) return { ...result, executionReady: false, oracleFee: fee };
+  return {
+    ...attachAutoSlippage(result, {
+      chainId,
+      venue: result?.priceRoute?.contractAddress || "paraswap-quote",
+      amountOut,
+      liquidityUsd: args.liquidityUsd,
+      priceChange5m: args.priceChange5m,
+      quoteAgeMs: 0,
+      requestedCapBps: args.maxSlippageBps ?? args.slippageBps,
+    }),
+    executionReady: false,
+    executionBlocker: "call prepare to bind the price route to a validated transaction",
+    oracleFee: fee,
+  };
+}
+
+export async function paraswapPrepare(args = {}, opts = {}) {
+  if (String(args.side || "SELL").toUpperCase() !== "SELL") {
+    throw new Error("paraswap: agentic prepare currently supports exact-input SELL only");
+  }
+  const chainId = Number(args.chainId || args.network || 1);
+  const userAddress = token(args.userAddress, "userAddress");
+  const quote = await paraswapPrice(args, opts);
+  const priceRoute = quote?.priceRoute;
+  const expectedTarget = String(priceRoute?.contractAddress || "").toLowerCase();
+  if (!expectedTarget) throw new Error("paraswap: price route missing contractAddress");
+  const body = {
+    srcToken: token(args.srcToken, "srcToken"),
+    destToken: token(args.destToken, "destToken"),
+    srcAmount: String(priceRoute.srcAmount || args.amount),
+    // ParaSwap treats destAmount as the on-chain minimum for SELL routes.
+    destAmount: String(quote.amountOutMinimum),
+    priceRoute,
+    userAddress,
+    ignoreChecks: false,
+    ignoreGasEstimate: false,
+  };
+  if (args.receiver) body.receiver = token(args.receiver, "receiver");
+  const tx = await httpJson(`${base(opts)}/transactions/${chainId}`, {
+    method: "POST",
+    body,
+    fetchImpl: opts.fetchImpl,
+    timeoutMs: opts.timeoutMs ?? 25_000,
+  });
+  if (Number(tx.chainId ?? chainId) !== chainId) throw new Error("paraswap: transaction chain mismatch");
+  if (String(tx.to || "").toLowerCase() !== expectedTarget) throw new Error("paraswap: transaction target mismatch");
+  if (tx.from && String(tx.from).toLowerCase() !== userAddress) throw new Error("paraswap: transaction sender mismatch");
+  return stampPrepared({
+    provider: "paraswap",
+    calldataReady: true,
+    // NOT executable authority. The bytes are assembled but nothing is signed:
+    // the user's wallet is still the only thing that can authorize this. The
+    // previous `executionReady: true` read as "cleared to execute" and trained
+    // agents to treat a quote as permission.
+    requiresUserSignature: true,
+    signingReady: false,
+    broadcastReady: false,
+    chainId,
+    quote,
+    autoSlippage: quote.autoSlippage,
+    requiresApproval: body.srcToken !== "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+      ? { token: body.srcToken, spender: priceRoute.tokenTransferProxy || expectedTarget, amount: body.srcAmount }
+      : null,
+    transaction: {
+      chainId,
+      from: tx.from || userAddress,
+      to: tx.to,
+      data: tx.data,
+      value: tx.value ?? "0x0",
+      ...(tx.gas != null ? { gasLimit: tx.gas } : {}),
+      slippageGuard: bindAutoSlippageGuardToCall(quote.autoSlippage, { chainId, venue: tx.to, data: tx.data }),
+    },
+  }, { provider: "paraswap", kind: "paraswap-tx" });
+}
+
+export async function paraswapHealth(opts = {}) {
+  const data = await paraswapTokens({ chainId: 1 }, opts);
+  const count = Array.isArray(data?.tokens) ? data.tokens.length : Object.keys(data?.tokens || {}).length;
+  return { ok: count > 0, tokenSample: count };
+}

package/src/data/providers/pendle.mjs

@@ -0,0 +1,188 @@
+// Pendle public core API — markets and Hosted SDK Convert tx builder, no key.
+import { getAddress } from "ethers";
+import { httpJson } from "../http.mjs";
+import { attachAutoSlippage, bindAutoSlippageGuardToCall, resolveAutoSlippage } from "../../auto-slippage.mjs";
+import { stampPrepared } from "../../prepare-envelope.mjs";
+
+export const PENDLE_API = "https://api-v2.pendle.finance/core";
+
+// Official Pendle Router from deployment docs. Bytecode checked via eth_getCode
+// on Arbitrum/Base 2026-07-23.
+export const PENDLE_ROUTER_BY_CHAIN = Object.freeze({
+  42161: "0x888888888889758F76e7103c6CbF23ABbF58F946",
+  8453: "0x888888888889758F76e7103c6CbF23ABbF58F946",
+});
+
+const ZERO = "0x0000000000000000000000000000000000000000";
+const NATIVE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+
+const base = (o = {}) => (o.baseUrl || process.env.PENDLE_API_URL || PENDLE_API).replace(/\/$/, "");
+
+function checksum(value, label) {
+  try {
+    return getAddress(value);
+  } catch {
+    throw new Error(`${label} must be a valid EVM address`);
+  }
+}
+
+function normal(value, label) {
+  return checksum(value, label).toLowerCase();
+}
+
+function isNative(value) {
+  const v = String(value || "").toLowerCase();
+  return v === "native" || v === "eth" || v === NATIVE || v === ZERO;
+}
+
+function amountString(value, label) {
+  let amount;
+  try {
+    amount = BigInt(String(value));
+  } catch {
+    throw new Error(`${label} must be an integer string`);
+  }
+  if (amount <= 0n) throw new Error(`${label} must be positive`);
+  return amount.toString();
+}
+
+function normalizeInputs(inputs) {
+  if (!Array.isArray(inputs) || inputs.length === 0) throw new Error("pendle convert requires inputs[]");
+  return inputs.map((input, i) => ({
+    token: checksum(input.token, `pendle input ${i} token`),
+    amount: amountString(input.amount, `pendle input ${i} amount`),
+  }));
+}
+
+function normalizeOutputs(outputs) {
+  if (!Array.isArray(outputs) || outputs.length === 0) throw new Error("pendle convert requires outputs[]");
+  return outputs.map((token, i) => checksum(token, `pendle output ${i} token`));
+}
+
+function routerFor(chainId) {
+  const router = PENDLE_ROUTER_BY_CHAIN[Number(chainId)];
+  if (!router) throw new Error(`Pendle prepare not enabled for chainId ${chainId}`);
+  return router;
+}
+
+function firstOutputAmount(result) {
+  const amount = result?.routes?.[0]?.outputs?.[0]?.amount || result?.outputs?.[0]?.amount;
+  if (!amount) throw new Error("Pendle convert response missing output amount");
+  return amountString(amount, "pendle output amount");
+}
+
+function normalizeRequiredApprovals(requiredApprovals, spender) {
+  const approvals = (Array.isArray(requiredApprovals) ? requiredApprovals : [])
+    .filter((approval) => approval?.token && approval?.amount && !isNative(approval.token))
+    .map((approval) => ({
+      token: normal(approval.token, "pendle approval token"),
+      spender: normal(spender, "pendle approval spender"),
+      amount: amountString(approval.amount, "pendle approval amount"),
+    }));
+  if (!approvals.length) return null;
+  return approvals.length === 1 ? approvals[0] : approvals;
+}
+
+export async function pendleMarkets(args = {}, opts = {}) {
+  const chainId = Number(args.chainId || 42161);
+  const p = new URLSearchParams({
+    limit: String(Math.min(100, Math.max(1, Number(args.limit || 20)))),
+    skip: String(Math.max(0, Number(args.skip || 0))),
+  });
+  if (args.isExpired != null) p.set("isExpired", String(Boolean(args.isExpired)));
+  return httpJson(`${base(opts)}/v1/${chainId}/markets?${p}`, {
+    fetchImpl: opts.fetchImpl,
+    timeoutMs: opts.timeoutMs,
+  });
+}
+
+export async function pendleHealth(opts = {}) {
+  const data = await pendleMarkets({ chainId: 42161, limit: 1 }, opts);
+  return { ok: Array.isArray(data?.results), marketSample: data?.results?.length || 0 };
+}
+
+export async function pendlePrepare(q = {}, opts = {}) {
+  const chainId = Number(q.chainId ?? 42161);
+  const router = routerFor(chainId);
+  const from = q.from || q.fromAddress || q.userAddress || q.taker || q.receiver;
+  if (!from) throw new Error("pendlePrepare requires from/receiver");
+  const receiver = checksum(q.receiver || from, "pendle receiver");
+  const inputs = normalizeInputs(q.inputs);
+  const outputs = normalizeOutputs(q.outputs);
+  if (q.enableAggregator === true || (Array.isArray(q.aggregators) && q.aggregators.length)) {
+    throw new Error("Pendle aggregator paths are disabled by policy; use direct convert only");
+  }
+  const selected = resolveAutoSlippage({
+    liquidityUsd: q.liquidityUsd,
+    priceChange5m: q.priceChange5m,
+    requestedCapBps: q.maxSlippageBps ?? q.slippageBps,
+  });
+  if (!selected.executable) {
+    throw new Error(`Pendle: route requires ${selected.requiredBps} bps above cap ${selected.capBps}`);
+  }
+  const body = {
+    receiver,
+    slippage: selected.selectedBps / 10_000,
+    enableAggregator: false,
+    useLimitOrder: false,
+    inputs,
+    outputs,
+    ...(q.redeemRewards != null ? { redeemRewards: Boolean(q.redeemRewards) } : {}),
+    ...(q.needScale != null ? { needScale: Boolean(q.needScale) } : {}),
+    ...(q.additionalData ? { additionalData: String(q.additionalData) } : {}),
+  };
+  const raw = await httpJson(`${base(opts)}/v3/sdk/${chainId}/convert`, {
+    method: "POST",
+    body,
+    fetchImpl: opts.fetchImpl,
+    timeoutMs: opts.timeoutMs ?? 25_000,
+  });
+  const route = raw?.routes?.[0];
+  const tx = route?.tx;
+  if (!tx?.to || !tx?.data) throw new Error("Pendle convert returned no executable tx");
+  if (normal(tx.to, "pendle tx target") !== normal(router, "pendle router")) {
+    throw new Error("Pendle convert returned unexpected router target");
+  }
+  if (tx.from && normal(tx.from, "pendle tx sender") !== normal(from, "pendle sender")) {
+    throw new Error("Pendle convert transaction sender mismatch");
+  }
+  const amountOut = firstOutputAmount(raw);
+  const quote = attachAutoSlippage(raw, {
+    chainId,
+    venue: tx.to,
+    amountOut,
+    liquidityUsd: q.liquidityUsd,
+    priceChange5m: q.priceChange5m,
+    requestedCapBps: q.maxSlippageBps ?? q.slippageBps,
+  });
+  return stampPrepared({
+    provider: "pendle",
+    calldataReady: true,
+    // NOT executable authority. The bytes are assembled but nothing is signed:
+    // the user's wallet is still the only thing that can authorize this. The
+    // previous `executionReady: true` read as "cleared to execute" and trained
+    // agents to treat a quote as permission.
+    requiresUserSignature: true,
+    signingReady: false,
+    broadcastReady: false,
+    chainId,
+    action: raw.action || null,
+    quote,
+    autoSlippage: quote.autoSlippage,
+    requiresApproval: normalizeRequiredApprovals(raw.requiredApprovals, tx.to),
+    transaction: {
+      chainId,
+      from: tx.from || from,
+      to: tx.to,
+      data: tx.data,
+      value: tx.value ?? "0x0",
+      slippageGuard: bindAutoSlippageGuardToCall(quote.autoSlippage, { chainId, venue: tx.to, data: tx.data }),
+    },
+  }, { provider: "pendle", kind: "pendle-swap" });
+}
+
+export async function pendleQuote(q = {}, opts = {}) {
+  const prepared = await pendlePrepare(q, opts);
+  const { transaction: _transaction, ...quote } = prepared;
+  return quote;
+}