@oracle-agent/oracle 0.9.8 → 0.11.0

package/src/cli/model-config.mjs

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { ensureDir, oracleConfigDir } from "./paths.mjs";
+
+const BACKENDS = new Set(["auto", "standalone", "hermes"]);
+const PROVIDERS = new Set([
+  "openrouter", "openai", "xai", "deepseek", "gemini", "custom",
+  "anthropic-oauth", "openai-codex", "xai-oauth",
+]);
+
+export function modelConfigPath() {
+  return path.join(oracleConfigDir(), "model.json");
+}
+
+function optionalString(value) {
+  const text = String(value || "").trim();
+  return text || undefined;
+}
+
+function normalize(config = {}) {
+  const backend = optionalString(config.backend)?.toLowerCase() || "auto";
+  const provider = optionalString(config.provider)?.toLowerCase();
+  const model = optionalString(config.model);
+  const baseUrl = optionalString(config.baseUrl)?.replace(/\/+$/, "");
+  const apiKeyEnv = optionalString(config.apiKeyEnv);
+  const contextLength = Number.parseInt(String(config.contextLength || ""), 10);
+  const reasoningEffort = optionalString(config.reasoningEffort);
+
+  if (!BACKENDS.has(backend)) throw new Error(`unsupported backend: ${backend}`);
+  if (provider && !PROVIDERS.has(provider)) throw new Error(`unsupported provider: ${provider}`);
+  if (baseUrl && provider !== "custom") throw new Error("baseUrl is only supported for the custom provider");
+  if (apiKeyEnv && !/^[A-Z][A-Z0-9_]*$/.test(apiKeyEnv)) throw new Error("api key env must be an uppercase environment variable name");
+  if (provider === "custom" && !baseUrl) throw new Error("custom provider requires baseUrl");
+  if (backend === "standalone" && !model) throw new Error("standalone backend requires a model");
+
+  return {
+    backend,
+    ...(provider ? { provider } : {}),
+    ...(model ? { model } : {}),
+    ...(baseUrl ? { baseUrl } : {}),
+    ...(apiKeyEnv ? { apiKeyEnv } : {}),
+    ...(Number.isFinite(contextLength) && contextLength > 0 ? { contextLength } : {}),
+    ...(reasoningEffort ? { reasoningEffort } : {}),
+  };
+}
+
+export function readModelConfig() {
+  const file = modelConfigPath();
+  if (!fs.existsSync(file)) return null;
+  try {
+    return normalize(JSON.parse(fs.readFileSync(file, "utf8")));
+  } catch {
+    return null;
+  }
+}
+
+export function writeModelConfig(config) {
+  const normalized = normalize(config);
+  const file = modelConfigPath();
+  ensureDir(path.dirname(file));
+  if (process.platform !== "win32") fs.chmodSync(path.dirname(file), 0o700);
+  const temp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temp, `${JSON.stringify(normalized, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temp, file);
+  if (process.platform !== "win32") fs.chmodSync(file, 0o600);
+  return normalized;
+}
+
+export default { modelConfigPath, readModelConfig, writeModelConfig };

package/src/data/catalog.mjs

@@ -1,8 +1,13 @@
 // Provider catalog — DATA plane registry. Wallet keys never live here.
 
+import { UNI_V3_CHAINS } from "./providers/uniswap-v3.mjs";
+import { UNI_V4_CHAINS } from "./providers/uniswap-v4.mjs";
+
 /** @typedef {{ id: string, venue: string, chainIds: number[], auth: 'none'|'apiKey'|'agentKey', ops: string[], baseEnv?: string[], description?: string }} ProviderMeta */
 
 const REGISTRY = new Map();
+const UNI_V3_CHAIN_IDS = Object.keys(UNI_V3_CHAINS).map(Number);
+const UNI_V4_CHAIN_IDS = Object.keys(UNI_V4_CHAINS).map(Number);
 const BUILTIN_PROVIDER_IDS = new Set();
 let BUILTINS_LOCKED = false;
 
@@ -211,9 +216,9 @@ registerProvider({
   venue: "solana-dex",
   chainIds: [],
   auth: "none",
-  ops: ["health", "quote", "prepare"],
+  ops: ["health", "venues", "quote", "prepare"],
   execution: "prepare",
-  baseEnv: ["JUPITER_SWAP_API_URL"],
+  baseEnv: ["JUPITER_SWAP_API_URL", "SOLANA_RPC_URL"],
   description: "Jupiter Swap API v1 quote + unsigned user-signature swap transaction preparation",
 });
 
@@ -304,7 +309,7 @@ registerProvider({
 registerProvider({
   id: "uniswap-v3",
   venue: "dex",
-  chainIds: [1, 8453, 42161],
+  chainIds: UNI_V3_CHAIN_IDS,
   auth: "none",
   ops: ["health", "quote", "prepare", "quotePath", "ethUsdc", "chains"],
   execution: "prepare",
@@ -312,8 +317,34 @@ registerProvider({
     "ETH_RPC_URL",
     "BASE_RPC_URL",
     "ARBITRUM_RPC_URL",
+    "OPTIMISM_RPC_URL",
+    "BSC_RPC_URL",
+    "POLYGON_RPC_URL",
+    "AVALANCHE_RPC_URL",
+    "RH_CHAIN_RPC",
+  ],
+  description: "Uniswap V3 QuoterV2 exact-in quotes via eth_call across official deployments plus Robinhood Chain, no key",
+});
+
+registerProvider({
+  id: "uniswap-v4",
+  venue: "dex",
+  chainIds: UNI_V4_CHAIN_IDS,
+  auth: "none",
+  ops: ["health", "quote", "chains"],
+  execution: "read-only",
+  baseEnv: [
+    "ETH_RPC_URL",
+    "BASE_RPC_URL",
+    "ARBITRUM_RPC_URL",
+    "OPTIMISM_RPC_URL",
+    "BSC_RPC_URL",
+    "POLYGON_RPC_URL",
+    "AVALANCHE_RPC_URL",
+    "RH_CHAIN_RPC",
   ],
-  description: "Uniswap V3 QuoterV2 exact-in quotes via eth_call (ETH/Base/Arb, no key)",
+  description:
+    "Uniswap V4 Quoter exact-in quotes via eth_call across official deployments plus Robinhood Chain. Quote-only until Universal Router prepare is classified.",
 });
 
 registerProvider({
@@ -503,7 +534,7 @@ registerProvider({
 registerProvider({
   id: "odos",
   venue: "dex",
-  chainIds: [1, 10, 56, 137, 8453, 42161, 43114],
+  chainIds: [1, 10, 56, 137, 8453, 42161, 43114, 4663],
   auth: "none",
   ops: ["health", "chains", "quote", "prepare"],
   // Tier is the honest signal here: the API returns HTTP 410 Gone as of
@@ -532,7 +563,7 @@ registerProvider({
 registerProvider({
   id: "paraswap",
   venue: "dex",
-  chainIds: [1, 10, 56, 137, 8453, 42161, 43114],
+  chainIds: [1, 10, 56, 137, 8453, 42161, 43114, 4663],
   auth: "none",
   ops: ["health", "tokens", "price", "quote", "prepare"],
   execution: "prepare",
@@ -543,7 +574,7 @@ registerProvider({
 registerProvider({
   id: "rfq",
   venue: "intent-rfq",
-  chainIds: [1, 10, 56, 137, 8453, 42161, 43114],
+  chainIds: [1, 10, 56, 137, 8453, 42161, 43114, 4663],
   auth: "none",
   ops: ["health", "intent", "quote"],
   execution: "prepare",

package/src/data/desk-data.mjs

@@ -15,6 +15,7 @@ import * as llama from "./providers/defillama.mjs";
 import * as lifi from "./providers/lifi.mjs";
 import * as dxs from "./providers/dexscreener.mjs";
 import * as uni from "./providers/uniswap-v3.mjs";
+import * as univ4 from "./providers/uniswap-v4.mjs";
 import * as aerodrome from "./providers/aerodrome.mjs";
 import * as zerox from "./providers/zerox.mjs";
 import * as bridges from "./providers/bridges.mjs";
@@ -144,6 +145,7 @@ const OPS = {
   },
   jupiter: {
     health: (o) => jupiter.jupiterHealth(o),
+    venues: (o, a = {}) => jupiter.jupiterVenues(a, o),
     quote: (o, a = {}) => jupiter.jupiterQuote(a, o),
     prepare: (o, a = {}) => jupiter.jupiterPrepareSwap(a, o),
   },
@@ -176,6 +178,11 @@ const OPS = {
     ethUsdc: (o, a = {}) => uni.uniV3EthUsdc(a, o),
     chains: () => uni.uniV3Chains(),
   },
+  "uniswap-v4": {
+    health: (o, a = {}) => univ4.uniV4Health({ ...o, chainId: a.chainId ?? 8453 }),
+    quote: (o, a = {}) => univ4.uniV4QuoteExactIn(a, o),
+    chains: () => univ4.uniV4Chains(),
+  },
   aerodrome: {
     health: (o, a = {}) => aerodrome.aerodromeHealth({ ...o, chainId: a.chainId ?? 8453 }),
     quote: (o, a = {}) => aerodrome.aerodromeQuoteExactIn(a, o),
@@ -665,6 +672,11 @@ export const data = {
     ethUsdc: (a, o) => dataCall("uniswap-v3", "ethUsdc", a || {}, o),
     chains: (o) => dataCall("uniswap-v3", "chains", {}, o),
   },
+  univ4: {
+    health: (a, o) => dataCall("uniswap-v4", "health", a || {}, o),
+    quote: (a, o) => dataCall("uniswap-v4", "quote", a || {}, o),
+    chains: (o) => dataCall("uniswap-v4", "chains", {}, o),
+  },
   bridges: {
     across: (a, o) => dataCall("across", "suggestedFees", a || {}, o),
     hop: (a, o) => dataCall("hop", "quote", a || {}, o),

package/src/data/providers/evm-rpc.mjs

@@ -61,25 +61,28 @@ export function resolveRpcUrl(chainId, { rpcUrl, env = process.env } = {}) {
  * @param {any[]} [params]
  */
 
-/** Prepare-only: write/settle JSON-RPC methods are hard-refused even on deep import. */
-const EVM_WRITE_RPC = new Set([
-  "eth_sendTransaction",
-  "eth_sendRawTransaction",
-  "eth_sign",
-  "eth_signTransaction",
-  "eth_signTypedData",
-  "eth_signTypedData_v4",
-  "personal_sign",
-]);
+// `rpcCall` is the raw public transport exposed by the data facade. It must be
+// an allowlist, not a partial write denylist: every unrecognized method is
+// unsafe to forward because vendors add write namespaces (`wallet_send*`,
+// `pm_sendUserOperation`, `mev_sendBundle`) faster than a denylist stays fresh.
+//
+// Canonical JSON-RPC method names are ASCII lowercase + underscores. Reject
+// whitespace, separator tricks, and Unicode homoglyphs rather than normalizing
+// them into a different network request.
+const EVM_READ_RPC = /^(?:eth_(?:call|blocknumber|chainid|get[a-z0-9]+|feehistory|gasprice|maxpriorityfeepergas|syncing|protocolversion|estimategas|createaccesslist)|net_(?:version|listening|peercount)|web3_(?:clientversion|sha3))$/;
+
+function readRpcMethod(method) {
+  const raw = String(method || "");
+  const probe = raw.toLowerCase();
+  if (raw !== raw.trim() || !/^[a-zA-Z0-9_]+$/.test(raw) || !EVM_READ_RPC.test(probe)) {
+    throw new Error(`evm-rpc: ${raw} refused — @oracle-agent/oracle is prepare-only (read RPC only; no broadcast/sign)`);
+  }
+  return probe;
+}
 
 export async function rpcCall(chainId, method, params = [], opts = {}) {
   const methodName = String(method || "");
-  if (EVM_WRITE_RPC.has(methodName) || /send|sign/i.test(methodName) && !/^eth_get|^eth_call|^eth_block|^eth_chain|^eth_fee|^eth_gas|^eth_max|^eth_sync|^net_|^web3_/.test(methodName)) {
-    // allowlist is positive for common reads; anything send/sign-shaped dies.
-    if (EVM_WRITE_RPC.has(methodName) || methodName.startsWith("eth_send") || methodName.includes("sign")) {
-      throw new Error(`evm-rpc: ${methodName} refused — @oracle-agent/oracle is prepare-only (no broadcast/sign)`);
-    }
-  }
+  readRpcMethod(methodName);
   const url = resolveRpcUrl(chainId, opts);
   if (!url) {
     throw new Error(

package/src/data/providers/jupiter-venues.mjs

@@ -0,0 +1,119 @@
+// Solana venue labels routed through the Jupiter aggregator provider.
+//
+// Preserved as source data on 2026-08-03: this roster previously existed only
+// as markup in the splash page, so deleting that markup silently deleted the
+// evidence behind the README/site claim. Data belongs in src/, not in a
+// presentation layer that a redesign can drop.
+//
+// 101 program labels resolving to 98 unique venue brands: Aldrin/Aldrin V2,
+// Orca V1/Orca V2, and SolFi/SolFi V2 are version variants of one venue.
+
+export const JUPITER_VENUE_LABELS = Object.freeze([
+  "1DEX",
+  "Aldrin",
+  "Aldrin V2",
+  "AlphaQ",
+  "Aquifer",
+  "BinaryFi",
+  "BisonFi",
+  "BisonFi Predict",
+  "Bonkswap",
+  "Boop.fun",
+  "Byreal",
+  "Carrot",
+  "Crema",
+  "Cropper",
+  "customizable",
+  "DefiTuna",
+  "Denali",
+  "Deriverse",
+  "DexLab",
+  "Dynamic Bonding Curve",
+  "Flint",
+  "Flux",
+  "FluxBeam",
+  "GatorSwap",
+  "Gavel",
+  "GoonFi V2",
+  "GooseFX GAMMA",
+  "Guacswap",
+  "Hadron",
+  "Heaven",
+  "Helium Network",
+  "Huma",
+  "HumidiFi",
+  "Hylo Exchange",
+  "Hylo Stability Pool",
+  "Invariant",
+  "Jupiter Lend Earn",
+  "JupiterRfqV2",
+  "JupLend AMM",
+  "Kipseli",
+  "LemmingsFi",
+  "Manifest",
+  "Mercurial",
+  "MetaDAO",
+  "Meteora",
+  "Meteora DAMM v2",
+  "Meteora DLMM",
+  "Metric",
+  "Moonit",
+  "more chains",
+  "M Swap",
+  "Obric V2",
+  "Obsidian",
+  "Omnipair",
+  "OpenBook V2",
+  "Orca V1",
+  "Orca V2",
+  "PancakeSwap",
+  "Penguin",
+  "Perena",
+  "Perena Star",
+  "Perps",
+  "Phoenix",
+  "protocol builder",
+  "Pump.fun",
+  "Pump.fun Amm",
+  "Quantum",
+  "Raydium",
+  "Raydium CLMM",
+  "Raydium CP",
+  "Raydium Launchlab",
+  "Riptide",
+  "RunnerRodeo",
+  "Saber",
+  "Saber (Decimals)",
+  "Sanctum",
+  "Sanctum Infinity",
+  "Saros",
+  "Saros DLMM",
+  "Scale Amm",
+  "Scale Vmm",
+  "Scorch",
+  "Solayer",
+  "SolFi",
+  "SolFi V2",
+  "Stabble CLMM",
+  "Stabble Stable Swap",
+  "Stabble Weighted Swap",
+  "StepN",
+  "TaurusFi",
+  "TesseraV",
+  "Token Swap",
+  "Trends",
+  "VaultLiquidUnstake",
+  "Virtuals",
+  "Voltr",
+  "WhaleStreet",
+  "Whirlpool",
+  "Woofi",
+  "XOrca",
+  "ZeroFi"
+]);
+
+/** Unique venue brands, collapsing version variants. */
+export function uniqueVenueBrands() {
+  const norm = (s) => s.toLowerCase().replace(/\s+v[0-9]+$/, "").replace(/[^a-z0-9]/g, "");
+  return new Set(JUPITER_VENUE_LABELS.map(norm));
+}

package/src/data/providers/jupiter.mjs

@@ -4,6 +4,7 @@
 import { httpJson } from "../http.mjs";
 import { solanaPubkey } from "./solana-rpc.mjs";
 import { stampPrepared } from "../../prepare-envelope.mjs";
+import { assertNoSignedMaterial } from "./signed-material-guard.mjs";
 
 export const JUPITER_SWAP_API = "https://lite-api.jup.ag/swap/v1";
 export const SOL_MINT = "So11111111111111111111111111111111111111112";
@@ -65,6 +66,131 @@ function solanaGuard(quote = {}, { quotedAtMs = Date.now(), ttlMs = DEFAULT_QUOT
   };
 }
 
+// Known BPF loaders. A program is only real if it is BOTH executable AND owned
+// by one of these. `executable: true` alone is claimable by any account, so
+// checking it in isolation is not proof.
+const SOLANA_LOADERS = new Set([
+  "BPFLoaderUpgradeab1e11111111111111111111111",
+  "BPFLoader2111111111111111111111111111111111",
+  "BPFLoader1111111111111111111111111111111111",
+]);
+
+const B58_ALPHA = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+function isSolanaPubkey(s) {
+  if (typeof s !== "string" || !s.length) return false;
+  let num = 0n;
+  for (const ch of s) {
+    const v = B58_ALPHA.indexOf(ch);
+    if (v < 0) return false;
+    num = num * 58n + BigInt(v);
+  }
+  let hex = num.toString(16);
+  if (hex.length % 2) hex = "0" + hex;
+  let bytes = hex.length / 2;
+  for (const ch of s) {
+    if (ch === "1") bytes++;
+    else break;
+  }
+  return bytes === 32;
+}
+
+export async function jupiterVenues(args = {}, opts = {}) {
+  const rpcUrl = args.rpc || opts.solanaRpc || process.env.SOLANA_RPC || "https://api.mainnet-beta.solana.com";
+  const fetchImpl = opts.fetchImpl || fetch;
+
+  const res = await fetchImpl(`${JUPITER_SWAP_API}/program-id-to-label`, {
+    signal: AbortSignal.timeout(Number(opts.timeoutMs) || 15_000),
+  });
+  if (!res.ok) throw new Error(`jupiter venue map failed: HTTP ${res.status}`);
+  const labelMap = await res.json();
+
+  const entries = Object.entries(labelMap);
+  const wellFormed = entries.filter(([id]) => isSolanaPubkey(id));
+  const verified = [];
+  const unresolved = entries
+    .filter(([id]) => !isSolanaPubkey(id))
+    .map(([id, label]) => ({ programId: id, label, reason: "malformed program id" }));
+
+  if (args.verify === false) {
+    return {
+      source: `${JUPITER_SWAP_API}/program-id-to-label`,
+      verified: wellFormed.map(([programId, label]) => ({ programId, label })),
+      unresolved,
+      verifiedOnChain: false,
+      totals: { fromRouterMap: entries.length, verified: wellFormed.length },
+    };
+  }
+
+  const call = async (body) => {
+    const r = await fetchImpl(rpcUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(Number(opts.timeoutMs) || 20_000),
+    });
+    const j = await r.json();
+    if (j.error) throw new Error(j.error.message);
+    return j.result;
+  };
+
+  for (let i = 0; i < wellFormed.length; i += 90) {
+    const chunk = wellFormed.slice(i, i + 90);
+    let out = null;
+    for (let attempt = 0; attempt < 3 && !out; attempt++) {
+      try {
+        out = await call({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "getMultipleAccounts",
+          params: [chunk.map(([id]) => id), { encoding: "base64", dataSlice: { offset: 0, length: 0 } }],
+        });
+      } catch {
+        await new Promise((r) => setTimeout(r, 2000 * (attempt + 1)));
+      }
+    }
+    if (!out) {
+      for (const [programId, label] of chunk) {
+        unresolved.push({ programId, label, reason: "rpc batch failed after 3 attempts" });
+      }
+      continue;
+    }
+    out.value.forEach((acc, k) => {
+      const [programId, label] = chunk[k];
+      if (acc && acc.executable === true && SOLANA_LOADERS.has(acc.owner)) {
+        verified.push({ programId, label, owner: acc.owner });
+      } else {
+        unresolved.push({
+          programId,
+          label,
+          reason: !acc ? "account not found" : acc.executable !== true ? "not executable" : `unknown owner ${acc.owner}`,
+        });
+      }
+    });
+    if (i + 90 < wellFormed.length) await new Promise((r) => setTimeout(r, 700));
+  }
+
+  const brands = new Set(
+    verified.map((v) => v.label.replace(/\s+(CLMM|CP|V\d+|Launchlab|DLMM|Pools?)$/i, "").trim())
+  );
+
+  return {
+    source: `${JUPITER_SWAP_API}/program-id-to-label`,
+    rpc: rpcUrl,
+    verifiedOnChain: true,
+    verifiedAt: new Date().toISOString(),
+    totals: {
+      fromRouterMap: entries.length,
+      verified: verified.length,
+      unresolved: unresolved.length,
+      distinctLabels: new Set(verified.map((v) => v.label)).size,
+      distinctBrands: brands.size,
+    },
+    verified: verified.sort((a, b) => a.label.localeCompare(b.label)),
+    unresolved,
+  };
+}
+
 export async function jupiterHealth(opts = {}) {
   try {
     const q = await jupiterQuote({ inputMint: SOL_MINT, outputMint: USDC_MINT, amount: "1000000", slippageBps: 50 }, opts);
@@ -142,6 +268,12 @@ export async function jupiterPrepareSwap(args = {}, opts = {}) {
   });
   const swapTransaction = base64Tx(response?.swapTransaction);
 
+  // Refuse pre-signed material by PRESENCE. The primary `swapTransaction` field
+  // stays unsigned, but the full upstream body was echoed as `raw` and
+  // hash-bound into the envelope, so a hostile endpoint could smuggle a signed
+  // sibling that downstream tooling might select instead.
+  assertNoSignedMaterial("jupiter", response);
+
   // Bind the returned transaction to the quote it claims to implement. A
   // compromised or impersonated endpoint can return any bytes while Oracle
   // stamps the optimistic quote on top; the user signs the bytes, not the

package/src/data/providers/magiceden-sol.mjs

@@ -9,6 +9,7 @@ import { httpJson } from "../http.mjs";
 import { solanaPubkey } from "./solana-rpc.mjs";
 import { resolveProviderEndpoint, credentialedHeaders } from "../provider-endpoint.mjs";
 import { stampPrepared } from "../../prepare-envelope.mjs";
+import { assertNoSignedMaterial } from "./signed-material-guard.mjs";
 
 export const MAGICEDEN_SOL_API = "https://api-mainnet.magiceden.dev/v2";
 export const LAMPORTS_PER_SOL = 1_000_000_000;
@@ -242,6 +243,10 @@ export async function magicEdenSolPrepareBuy(args = {}, opts = {}) {
     fetchImpl: opts.fetchImpl,
     timeoutMs: opts.timeoutMs ?? 15_000,
   });
+  // Refuse pre-signed material by PRESENCE, before selecting unsigned bytes.
+  // A mixed payload (valid unsigned bytes plus a signed sibling) previously
+  // skipped this check entirely and bound the signed field into the envelope.
+  assertNoSignedMaterial("magiceden", raw);
   const data = raw?.v0?.tx?.data ?? raw?.tx?.data ?? null;
   // Accept ONLY the documented unsigned instruction field. A pre-signed payload
   // (txSigned) from a compromised or impersonated API must never be laundered
@@ -299,6 +304,10 @@ export async function magicEdenSolPrepareList(args = {}, opts = {}) {
     fetchImpl: opts.fetchImpl,
     timeoutMs: opts.timeoutMs ?? 15_000,
   });
+  // Refuse pre-signed material by PRESENCE, before selecting unsigned bytes.
+  // A mixed payload (valid unsigned bytes plus a signed sibling) previously
+  // skipped this check entirely and bound the signed field into the envelope.
+  assertNoSignedMaterial("magiceden", raw);
   const data = raw?.v0?.tx?.data ?? raw?.tx?.data ?? null;
   if (!Array.isArray(data)) {
     if (raw?.txSigned) throw new Error("magiceden: refused a pre-signed transaction payload from the API");
@@ -365,6 +374,10 @@ export async function magicEdenSolPrepareMint(args = {}, opts = {}) {
     );
   }
 
+  // Refuse pre-signed material by PRESENCE, before selecting unsigned bytes.
+  // A mixed payload (valid unsigned bytes plus a signed sibling) previously
+  // skipped this check entirely and bound the signed field into the envelope.
+  assertNoSignedMaterial("magiceden", raw);
   const data = raw?.v0?.tx?.data ?? raw?.tx?.data ?? null;
   if (!Array.isArray(data)) {
     if (raw?.txSigned) throw new Error("magiceden: refused a pre-signed transaction payload from the API");

package/src/data/providers/morpho.mjs

@@ -5,6 +5,7 @@
 import { Interface, getAddress, isAddress, keccak256, toUtf8Bytes } from "ethers";
 import { httpJson } from "../http.mjs";
 import { rpcCall as defaultRpcCall } from "./evm-rpc.mjs";
+import { stampPrepared } from "../../prepare-envelope.mjs";
 
 export const MORPHO_API = "https://api.morpho.org/graphql";
 
@@ -146,11 +147,14 @@ export async function morphoPrepareVault(args = {}, opts = {}) {
   };
   vaultGuard.guardHash = keccak256(toUtf8Bytes(canonicalJson(vaultGuard)));
 
-  return {
+  return stampPrepared({
     provider: "morpho",
     protocol: "erc4626-vault",
     vaultReady: true,
     executionReady: false,
+    signingReady: false,
+    broadcastReady: false,
+    requiresUserSignature: true,
     chainId,
     action,
     vault,
@@ -169,5 +173,5 @@ export async function morphoPrepareVault(args = {}, opts = {}) {
       value: "0x0",
       madVault: vaultGuard,
     },
-  };
+  }, { provider: "morpho", kind: "erc4626-vault" });
 }

package/src/data/providers/pendle.mjs

@@ -2,6 +2,7 @@
 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";
 
@@ -154,7 +155,7 @@ export async function pendlePrepare(q = {}, opts = {}) {
     priceChange5m: q.priceChange5m,
     requestedCapBps: q.maxSlippageBps ?? q.slippageBps,
   });
-  return {
+  return stampPrepared({
     provider: "pendle",
     calldataReady: true,
     // NOT executable authority. The bytes are assembled but nothing is signed:
@@ -177,7 +178,7 @@ export async function pendlePrepare(q = {}, opts = {}) {
       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 = {}) {

package/src/data/providers/satflow.mjs

@@ -8,6 +8,7 @@
 import { btcAddress } from "./bitcoin-esplora.mjs";
 import { resolveProviderEndpoint, credentialedHeaders } from "../provider-endpoint.mjs";
 import { stampPrepared } from "../../prepare-envelope.mjs";
+import { assertNoSignedMaterial } from "./signed-material-guard.mjs";
 
 export const SATFLOW_BASE = "https://api.satflow.com/v1";
 
@@ -295,6 +296,8 @@ export async function satflowPreparePurchase(args = {}, opts = {}) {
     throw new Error(`satflow: purchase price ${settled} sats exceeds maxSats cap ${maxSats} — PSBT withheld`);
   }
 
+  assertNoSignedMaterial("satflow", data);
+
   return stampPrepared({
     provider: "satflow",
     kind: "purchase-intent",
@@ -312,7 +315,6 @@ export async function satflowPreparePurchase(args = {}, opts = {}) {
       data?.unsignedPSBTBase64 ||
       data?.unsignedPsbtBase64 ||
       data?.unsigned_psbt ||
-      data?.psbt ||
       null,
     note: "Sign PSBT in a Bitcoin wallet. Broadcast only through the user's wallet or an explicitly armed Bitcoin execution plane.",
   });
@@ -325,6 +327,7 @@ export async function satflowPrepareList(args = {}, opts = {}) {
     throw new Error("satflow: list requires inscription_id or runes_output");
   }
   const data = await sfFetch("/intent/sell", { method: "POST", body, opts });
+  assertNoSignedMaterial("satflow", data);
   return stampPrepared({
     provider: "satflow",
     kind: "list-intent",