@oracle-agent/oracle 0.9.8 → 0.11.0

package/scripts/check-doc-drift.mjs

@@ -60,6 +60,17 @@ function checkVersionPins(rel, text) {
         `${rel}:${i + 1} advertises oracle ${latest[1]} as latest but this package is ${pkg.version}\n    ${line.trim().slice(0, 120)}`,
       );
     }
+    // The 2026-08-03 grok lane found `Source tree: **oracle \`0.5.0\`**` and a
+    // `Published npm: **oracle \`0.4.2\`**` line surviving inside a 0.10.0
+    // tarball. Both shapes sailed past the two matchers above, so a stranger
+    // reading the shipped README saw a version five releases stale. Match any
+    // prose that states an oracle version, not just the two blessed prefixes.
+    const stated = line.match(/oracle\s+`(\d+\.\d+\.\d+)`/i);
+    if (stated && stated[1] !== pkg.version) {
+      failures.push(
+        `${rel}:${i + 1} states oracle ${stated[1]} but this package is ${pkg.version}\n    ${line.trim().slice(0, 120)}`,
+      );
+    }
   });
 }
 

package/scripts/e2e-solana-bitcoin.mjs

@@ -9,7 +9,7 @@ import { jupiterQuote, jupiterPrepareSwap, SOL_MINT, USDC_MINT } from "../src/da
 import { solanaSimulateTransaction } from "../src/data/providers/solana-rpc.mjs";
 import { magicEdenSolStats, magicEdenSolListings, magicEdenSolPrepareBuy } from "../src/data/providers/magiceden-sol.mjs";
 
-const PROBE_WALLET = process.env.ORACLE_E2E_SOL_PUBKEY || "11111111111111111111111111111111";
+const PROBE_WALLET = process.env.ORACLE_E2E_SOL_PUBKEY || "DtM6A1ivwvFeT14f7ggTAGvpUTZA5LeutV3rLe8wR6U3";
 const PROBE_BTC = process.env.ORACLE_E2E_BTC_ADDRESS || "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq";
 
 const results = [];

package/scripts/secret-scan.mjs

@@ -6,7 +6,7 @@
 
 import { execFileSync } from "node:child_process";
 
-const ROOT = process.cwd();
+const ROOT = execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd: process.cwd(), encoding: "utf8" }).trim();
 
 // Live values that must never appear. Sourced from the environment at scan
 // time so the scanner itself contains no secrets.

package/src/action-receipts.mjs

@@ -4,17 +4,89 @@
 // sign, broadcast, or fetch. It only records facts supplied by its caller.
 
 import { createHash } from "node:crypto";
+import { wordlists } from "ethers";
 
 export const ACTION_RECEIPT_VERSION = 1;
 
+// Key-name matching was exact-ish and only covered five words, so every wallet
+// export alias (secretKey, seedPhrase, wif, keyMaterial, privKey, xprv, seed,
+// keystore) sailed through. There was also NO value-shape rule, so a raw key or
+// a BIP-39 phrase pasted into a benign field like `memo` was recorded verbatim.
+//
+// Both concerns were already solved in src/address-book.mjs; this module simply
+// did not use the hardened list. Found by the opus lane of the 2026-08-03
+// four-model review, and verified to PERSIST: unknown top-level props are
+// dropped by the schema whitelist, but a secret nested inside a RETAINED field
+// (intent, route, decodedAction) survives into the frozen receipt.
 const SECRET_KEYS = new Set([
   "privatekey",
+  "privkey",
+  "secretkey",
+  "seedphrase",
+  "seed",
   "mnemonic",
+  "passphrase",
+  "password",
+  "keystore",
+  "keymaterial",
+  "wif",
+  "xprv",
+  "xpriv",
   "bearer",
   "authorization",
   "signature",
+  "apikey",
+  "credential",
+]);
+
+// Unambiguous key shapes: WIF, extended private key, BIP-39 word run. These are
+// refused wherever they appear.
+//
+// A bare 64-hex string is deliberately NOT in this list. A raw EVM private key
+// and a bytes32 tx hash are byte-identical, and receipts legitimately carry
+// txHash / orderHash / salt / merkleRoot / nonce. Blanket-refusing 64-hex would
+// break real receipts — an over-tight filter is its own bug. It is instead
+// gated on the field name below.
+const KEY_SHAPED_VALUE = [
+  /\b[5KL][1-9A-HJ-NP-Za-km-z]{50,51}\b/,
+  /\bxprv[0-9A-Za-z]{50,}\b/,
+];
+
+const BIP39_WORD_COUNTS = new Set([12, 15, 18, 21, 24]);
+
+function isBip39EnglishPhrase(value) {
+  const words = String(value).trim().toLowerCase().split(/\s+/).filter(Boolean);
+  return BIP39_WORD_COUNTS.has(words.length) && words.every((word) => wordlists.en.getWordIndex(word) >= 0);
+}
+
+const BARE_32_BYTE_HEX = /^\s*(?:0x)?[0-9a-fA-F]{64}\s*$/;
+
+// Field names whose whole value is EXPECTED to be a 32-byte digest.
+//
+// The trailing `(?:e?s)?` matters: `publicValue` scans array leaves using the
+// PARENT key, so a batched route's `orderHashes` / `proofs` / `commitments`
+// arrives here in its plural form (English pluralizes `hash` as `hashes`).
+// Without it a digest LIST is refused while the exact same digest in singular
+// form is accepted — an over-tight filter that breaks real receipts and blocks
+// no secret (key-SHAPED values are refused by KEY_SHAPED_VALUE / BIP-39
+// regardless of field name).
+const DIGEST_FIELD = /(hash|digest|root|salt|nonce|proof|commitment|sig|id)(?:e?s)?$/i;
+const PROTOCOL_HEX_FIELDS = new Set([
+  "calldata",
+  "data",
+  "publickey",
+  "pubkey",
+  "message",
+  "payload",
+  "input",
+  "extradata",
 ]);
 
+function allows32ByteHex(key) {
+  const normalized = normalizedKey(key);
+  return PROTOCOL_HEX_FIELDS.has(normalized) || DIGEST_FIELD.test(normalized);
+}
+
 export class ActionReceiptSecretError extends Error {
   constructor(path) {
     super(`action receipt refused: secret-bearing field at ${path}`);
@@ -32,23 +104,45 @@ function isSecretKey(key) {
   return [...SECRET_KEYS].some((secret) => normalized.includes(secret));
 }
 
-function publicValue(value, path = "$") {
-  if (value == null || typeof value === "string" || typeof value === "boolean") return value;
+/**
+ * Refuse a key-material-shaped VALUE, so a secret pasted into a benign field
+ * name (memo, note, label) cannot be recorded verbatim.
+ *
+ * Bare 64-hex is only refused when the field name is NOT digest-shaped: a raw
+ * EVM private key and a bytes32 hash are byte-identical, and receipts carry
+ * txHash / orderHash / salt / nonce legitimately.
+ */
+function assertNoSecretValue(key, value, path) {
+  if (typeof value !== "string") return;
+  if (KEY_SHAPED_VALUE.some((re) => re.test(value)) || isBip39EnglishPhrase(value)) {
+    throw new ActionReceiptSecretError(path);
+  }
+  if (BARE_32_BYTE_HEX.test(value) && !allows32ByteHex(key)) {
+    throw new ActionReceiptSecretError(path);
+  }
+}
+
+function publicValue(value, path = "$", key = "") {
+  if (value == null || typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    assertNoSecretValue(key, value, path);
+    return value;
+  }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) throw new TypeError(`action receipt: non-finite number at ${path}`);
     return value;
   }
   if (typeof value === "bigint") return value.toString();
-  if (Array.isArray(value)) return value.map((item, index) => publicValue(item, `${path}[${index}]`));
+  if (Array.isArray(value)) return value.map((item, index) => publicValue(item, `${path}[${index}]`, key));
   if (typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype) {
     throw new TypeError(`action receipt: JSON-like value required at ${path}`);
   }
 
   const out = {};
-  for (const key of Object.keys(value).sort()) {
-    const childPath = `${path}.${key}`;
-    if (isSecretKey(key)) throw new ActionReceiptSecretError(childPath);
-    if (value[key] !== undefined) out[key] = publicValue(value[key], childPath);
+  for (const childKey of Object.keys(value).sort()) {
+    const childPath = `${path}.${childKey}`;
+    if (isSecretKey(childKey)) throw new ActionReceiptSecretError(childPath);
+    if (value[childKey] !== undefined) out[childKey] = publicValue(value[childKey], childPath, childKey);
   }
   return out;
 }
@@ -58,12 +152,15 @@ export function assertNoReceiptSecrets(value) {
   return publicValue(value);
 }
 
+function canonicalPublicJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalPublicJson).join(",")}]`;
+  return `{${Object.keys(value).map((key) => `${JSON.stringify(key)}:${canonicalPublicJson(value[key])}`).join(",")}}`;
+}
+
 /** Canonical JSON with recursively sorted object keys. */
 export function canonicalReceiptJson(value) {
-  const safe = publicValue(value);
-  if (safe === null || typeof safe !== "object") return JSON.stringify(safe);
-  if (Array.isArray(safe)) return `[${safe.map(canonicalReceiptJson).join(",")}]`;
-  return `{${Object.keys(safe).map((key) => `${JSON.stringify(key)}:${canonicalReceiptJson(safe[key])}`).join(",")}}`;
+  return canonicalPublicJson(publicValue(value));
 }
 
 /** Hash exactly the public receipt fields, excluding the self-referential id. */