@oracle-agent/oracle 0.11.0 → 0.12.0

package/src/profile-upgrade.mjs

@@ -1,277 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { randomBytes } from "node:crypto";
-import { createRequire } from "node:module";
-
-export const UPGRADE_VERSION = "oracle-profile-upgrade/v1";
-
-function exists(file) {
-  try { fs.accessSync(file); return true; } catch { return false; }
-}
-
-function snapshot(dir) {
-  if (!exists(dir)) return [];
-  return fs.readdirSync(dir, { recursive: true, withFileTypes: true })
-    .filter((entry) => entry.isFile())
-    .map((entry) => path.join(entry.parentPath || entry.path, entry.name))
-    .sort()
-    .map((file) => [path.relative(dir, file), fs.readFileSync(file)]);
-}
-
-function desiredTree(source) {
-  const files = snapshot(source);
-  files.push([".oracle-upgrade-version", Buffer.from(`${UPGRADE_VERSION}\n`)]);
-  return files.sort(([a], [b]) => a.localeCompare(b));
-}
-
-function treeMatches(dest, files) {
-  const actual = snapshot(dest);
-  return actual.length === files.length && actual.every(([name, body], i) =>
-    name === files[i][0] && body.equals(files[i][1]));
-}
-
-function tempSibling(target) {
-  return `${target}.tmp-oracle-upgrade-${process.pid}-${randomBytes(6).toString("hex")}`;
-}
-
-function backupName(target) {
-  let candidate = `${target}.bak-oracle-upgrade`;
-  for (let n = 1; exists(candidate); n += 1) candidate = `${target}.bak-oracle-upgrade-${n}`;
-  return candidate;
-}
-
-function installTree(source, dest, apply, report) {
-  if (!exists(source) || !fs.statSync(source).isDirectory()) return;
-  const files = desiredTree(source);
-  if (treeMatches(dest, files)) {
-    report.unchanged.push(dest);
-    return;
-  }
-  const wasPresent = exists(dest);
-  (wasPresent ? report.updated : report.created).push(dest);
-  if (!apply) return;
-  fs.mkdirSync(path.dirname(dest), { recursive: true });
-  const tmp = tempSibling(dest);
-  let backup = null;
-  fs.mkdirSync(tmp);
-  try {
-    for (const [name, body] of files) {
-      const out = path.join(tmp, name);
-      fs.mkdirSync(path.dirname(out), { recursive: true });
-      fs.writeFileSync(out, body);
-    }
-    if (wasPresent) {
-      backup = backupName(dest);
-      fs.renameSync(dest, backup);
-      report.backups.push({ path: backup, original: dest });
-    }
-    fs.renameSync(tmp, dest);
-  } catch (error) {
-    if (exists(tmp)) fs.rmSync(tmp, { recursive: true, force: true });
-    if (backup && !exists(dest) && exists(backup)) fs.renameSync(backup, dest);
-    throw error;
-  }
-}
-
-// This deliberately accepts only the ordinary block-style YAML Hermes writes.
-// Unsupported constructs fail closed rather than risking a lossy rewrite.
-function validateYaml(text, file) {
-  if (/^mcp_servers:[ \t]*(?!\{\}[ \t]*(?:#.*)?$)\S+/m.test(text)) {
-    throw new Error(`${file}: mcp_servers must be a block mapping`);
-  }
-  const stack = [];
-  const keys = new Map();
-  const lines = text.split(/\r?\n/);
-  let flow = 0;
-  for (let index = 0; index < lines.length; index += 1) {
-    const raw = lines[index];
-    if (/^\s*#/.test(raw)) continue;
-    if (/^\s*\t|^ +\t/.test(raw)) throw new Error(`${file}:${index + 1}: tabs are not supported in YAML indentation`);
-    const line = raw.replace(/\s+#.*$/, "");
-    if (!line.trim() || /^\s*(?:---|\.\.\.)\s*$/.test(line)) continue;
-    const quoteFree = line.replace(/'(?:[^']|'')*'|"(?:[^"\\]|\\.)*"/g, "");
-    for (const char of quoteFree) {
-      if ("[{".includes(char)) flow += 1;
-      if ("]}".includes(char)) flow -= 1;
-      if (flow < 0) throw new Error(`${file}:${index + 1}: unbalanced flow collection`);
-    }
-    if (/^\s*[^#\-][^:]*:\s*(?:.*)?$/.test(line)) {
-      const indent = line.match(/^ */)[0].length;
-      const key = line.trimStart().match(/^([^:]+):/)[1].trim();
-      while (stack.length && stack.at(-1).indent >= indent) stack.pop();
-      const parent = stack.map((item) => item.key).join("/");
-      const id = `${parent}|${indent}|${key}`;
-      if (keys.has(id)) throw new Error(`${file}:${index + 1}: duplicate mapping key ${key}`);
-      keys.set(id, true);
-      if (/^[^:]+:\s*(?:#.*)?$/.test(line.trimStart())) stack.push({ indent, key });
-    } else if (!/^\s*-\s+/.test(line) && flow === 0) {
-      throw new Error(`${file}:${index + 1}: unsupported or malformed YAML`);
-    }
-  }
-  if (flow !== 0) throw new Error(`${file}: unbalanced flow collection`);
-  if (/^\s*[^#\n]*:\s*[>|][+-]?\s*$/m.test(text)) {
-    // Block scalars are safe to preserve outside mcp_servers, but editing inside
-    // one would require a complete YAML parser.
-    const mcp = topLevelBlock(text, "mcp_servers");
-    if (mcp && /:\s*[>|][+-]?\s*$/m.test(mcp.body)) throw new Error(`${file}: block scalars inside mcp_servers are unsupported`);
-  }
-}
-
-function topLevelBlock(text, name) {
-  const re = new RegExp(`^${name}:[^\\S\\r\\n]*(?:#.*)?$`, "m");
-  const match = re.exec(text);
-  if (!match) return null;
-  const start = match.index;
-  const bodyStart = text.indexOf("\n", start) + 1;
-  if (!bodyStart) return { start, end: text.length, bodyStart: text.length, body: "" };
-  const rest = text.slice(bodyStart);
-  const next = /^(?=\S[^\r\n]*:)/m.exec(rest);
-  const end = next ? bodyStart + next.index : text.length;
-  return { start, bodyStart, end, body: text.slice(bodyStart, end) };
-}
-
-function scalar(value) {
-  return JSON.stringify(value);
-}
-
-function serverBlock(name, command) {
-  const words = command.command === "node" ? [command.script] : command.args;
-  const lines = [`  ${name}:`, `    command: ${scalar(command.command)}`];
-  if (words?.length) lines.push("    args:", ...words.map((arg) => `      - ${scalar(arg)}`));
-  lines.push("    enabled: true", `    # ${UPGRADE_VERSION}`);
-  return `${lines.join("\n")}\n`;
-}
-
-function mergeMcp(text, desired) {
-  text = text.replace(
-    /^(mcp_servers:)\s*\{\}\s*(#.*)?$/m,
-    (_line, head, comment) => `${head}${comment ? ` ${comment}` : ""}`,
-  );
-  const block = topLevelBlock(text, "mcp_servers");
-  if (!block) {
-    const prefix = text.length && !text.endsWith("\n") ? "\n" : "";
-    return `${text}${prefix}mcp_servers:\n${[...desired].map(([n, c]) => serverBlock(n, c)).join("")}`;
-  }
-  let body = block.body;
-  for (const [name, command] of desired) {
-    const child = new RegExp(`^  ${name}:[^\\S\\r\\n]*(?:#.*)?\\r?\\n(?:^(?: {3,}|\\s*$).*\\r?\\n?)*`, "m");
-    const replacement = serverBlock(name, command);
-    body = child.test(body) ? body.replace(child, replacement) : `${body}${body && !body.endsWith("\n") ? "\n" : ""}${replacement}`;
-  }
-  return `${text.slice(0, block.bodyStart)}${body}${text.slice(block.end)}`;
-}
-
-function mergeEnabledPlugin(text, pluginId) {
-  text = text.replace(
-    /^(plugins:)\s*\{\}\s*(#.*)?$/m,
-    (_line, head, comment) => `${head}${comment ? ` ${comment}` : ""}`,
-  );
-  const item = `    - ${scalar(pluginId)}\n`;
-  const block = topLevelBlock(text, "plugins");
-  if (!block) {
-    const prefix = text.length && !text.endsWith("\n") ? "\n" : "";
-    return `${text}${prefix}plugins:\n  enabled:\n${item}`;
-  }
-  let body = block.body;
-  const flow = /^  enabled:\s*\[([^\]]*)\](.*)$/m.exec(body);
-  if (flow) {
-    const values = flow[1].split(",").map((value) => value.trim().replace(/^["']|["']$/g, ""));
-    if (!values.includes(pluginId)) {
-      const joined = flow[1].trim() ? `${flow[1].trimEnd()}, ${scalar(pluginId)}` : scalar(pluginId);
-      body = body.replace(flow[0], `  enabled: [${joined}]${flow[2]}`);
-    }
-  } else {
-    const sequence = /^  enabled:\s*(?:#.*)?\r?\n((?:^ {4}-.*\r?\n?)*)/m.exec(body);
-    if (sequence) {
-      const values = sequence[1].split(/\r?\n/).map((line) => line.replace(/^\s*-\s*/, "").trim().replace(/^["']|["']$/g, ""));
-      if (!values.includes(pluginId)) body = body.replace(sequence[0], `${sequence[0]}${item}`);
-    } else {
-      body = `${body}${body && !body.endsWith("\n") ? "\n" : ""}  enabled:\n${item}`;
-    }
-  }
-  return `${text.slice(0, block.bodyStart)}${body}${text.slice(block.end)}`;
-}
-
-function writeAtomic(file, body, report) {
-  const present = exists(file);
-  const old = present ? fs.readFileSync(file, "utf8") : null;
-  if (old === body) { report.unchanged.push(file); return; }
-  (present ? report.updated : report.created).push(file);
-  if (!report.applied) return;
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  if (present) {
-    const backup = backupName(file);
-    fs.copyFileSync(file, backup);
-    report.backups.push({ path: backup, original: file });
-  }
-  const tmp = tempSibling(file);
-  try {
-    fs.writeFileSync(tmp, body, { mode: present ? fs.statSync(file).mode : 0o600 });
-    fs.renameSync(tmp, file);
-  } catch (error) {
-    if (exists(tmp)) fs.rmSync(tmp, { force: true });
-    throw error;
-  }
-}
-
-function resolveControl(packageRoot, explicit) {
-  if (explicit) {
-    const [command, ...args] = explicit;
-    return { command, args };
-  }
-  const candidates = [
-    path.join(packageRoot, "bin", "oracle-control-mcp.mjs"),
-    path.join(packageRoot, "plugins", "oracle-owner-gate", "bin", "oracle-control-mcp.mjs"),
-    path.join(packageRoot, "plugins", "oracle-owner-gate", "oracle-control-mcp.mjs"),
-    // Control MCP ships with the local operator package, not the prepare-only public root.
-    path.join(packageRoot, "..", "@oracle-agent", "operator", "bin", "oracle-control-mcp.mjs"),
-    path.join(packageRoot, "..", "..", "@oracle-agent", "operator", "bin", "oracle-control-mcp.mjs"),
-  ];
-  for (const script of candidates) {
-    if (exists(script) && fs.statSync(script).isFile()) return { command: "node", script: path.resolve(script) };
-  }
-  try {
-    const require = createRequire(path.join(packageRoot, "package.json"));
-    const operatorPkg = path.dirname(require.resolve("@oracle-agent/operator/package.json"));
-    const script = path.join(operatorPkg, "bin", "oracle-control-mcp.mjs");
-    if (exists(script) && fs.statSync(script).isFile()) return { command: "node", script: path.resolve(script) };
-  } catch {}
-  return null;
-}
-
-export function upgradeProfiles({ hermesHome, packageRoot, only = null, apply = false, controlCommand = null }) {
-  const profilesRoot = path.join(hermesHome, "profiles");
-  const report = { ok: true, applied: apply, version: UPGRADE_VERSION, hermesHome, packageRoot, profiles: [], created: [], updated: [], unchanged: [], backups: [] };
-  let profiles = exists(profilesRoot) ? fs.readdirSync(profilesRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort() : [];
-  if (only) profiles = profiles.filter((name) => name === only);
-  if (only && profiles.length === 0) throw new Error(`profile not found: ${only}`);
-  report.profiles = profiles;
-
-  // Validate every selected config before planning or performing any write.
-  const configs = new Map();
-  for (const profile of profiles) {
-    const file = path.join(profilesRoot, profile, "config.yaml");
-    const text = exists(file) ? fs.readFileSync(file, "utf8") : "";
-    validateYaml(text, file);
-    configs.set(profile, text);
-  }
-
-  const skillSource = path.join(packageRoot, "skills", "oracle-action-semantics");
-  if (!exists(skillSource)) throw new Error(`required Oracle skill is missing: ${skillSource}`);
-  const pluginSource = path.join(packageRoot, "plugins", "oracle-owner-gate");
-  const control = resolveControl(packageRoot, controlCommand);
-  const dataScript = path.join(packageRoot, "bin", "oracle-data-mcp.mjs");
-  if (!exists(dataScript)) throw new Error(`oracle-data MCP command is missing: ${dataScript}`);
-
-  for (const profile of profiles) {
-    const root = path.join(profilesRoot, profile);
-    installTree(skillSource, path.join(root, "skills", "oracle-action-semantics"), apply, report);
-    if (exists(pluginSource)) installTree(pluginSource, path.join(root, "plugins", "oracle-owner-gate"), apply, report);
-    const desired = new Map([["oracle-data", { command: "node", script: dataScript }]]);
-    if (control) desired.set("oracle-control", control);
-    let config = mergeMcp(configs.get(profile), desired);
-    if (exists(pluginSource)) config = mergeEnabledPlugin(config, "oracle-owner-gate");
-    writeAtomic(path.join(root, "config.yaml"), config, report);
-  }
-  return report;
-}

package/src/protocol-execution.mjs

@@ -1,84 +0,0 @@
-import { isAddress } from "ethers";
-import { assertAutoSlippageGuard } from "./auto-slippage.mjs";
-
-export const EXECUTABLE_PROTOCOL_PROVIDERS = Object.freeze([
-  "lifi",
-  "relay",
-  "uniswap-v3",
-  "aerodrome",
-  "zerox",
-  "paraswap",
-  "odos",
-  "oneinch",
-  "pendle",
-  "balancer",
-  "curve",
-]);
-
-function hexData(value) {
-  const data = String(value || "");
-  return /^0x(?:[0-9a-fA-F]{2})*$/.test(data);
-}
-
-function sameAddress(left, right) {
-  return String(left || "").toLowerCase() === String(right || "").toLowerCase();
-}
-
-/**
- * Validate a provider-produced executable route before it may cross into the
- * generic signer. This function accepts no caller-supplied destination/calldata;
- * those must come from the provider's freshly generated route.
- */
-export function assertPreparedProtocolRoute(
-  route,
-  { provider, chainId, from, nowMs = Date.now() } = {}
-) {
-  // `calldataReady` means the provider assembled real calldata from a fresh
-  // quote. It deliberately does NOT mean "cleared to execute" — the user's
-  // wallet is still the only authority. The old flag name was `executionReady`,
-  // which read as permission and trained agents to treat a quote as authority.
-  const prepared = route && (route.calldataReady === true || route.executionReady === true);
-  if (!prepared) {
-    throw new Error(`${provider || "protocol"}: executable provider preparation required`);
-  }
-  if (provider && route.provider !== provider) {
-    throw new Error(`protocol provider mismatch: expected ${provider}, got ${route.provider || "unknown"}`);
-  }
-  if (Number(route.chainId) !== Number(chainId)) {
-    throw new Error(`protocol route chain mismatch: expected ${chainId}, got ${route.chainId}`);
-  }
-  const raw = Array.isArray(route.transactions) ? route.transactions : [route.transaction];
-  if (!raw.length || raw.some((tx) => !tx)) throw new Error("protocol route has no executable transaction");
-
-  return raw.map((tx, index) => {
-    if (Number(tx.chainId ?? route.chainId) !== Number(chainId)) {
-      throw new Error(`protocol transaction ${index} chain mismatch`);
-    }
-    if (!isAddress(String(tx.to || ""))) throw new Error(`protocol transaction ${index} target must be an address`);
-    if (!hexData(tx.data) || String(tx.data).length < 10) {
-      throw new Error(`protocol transaction ${index} requires non-empty hex calldata`);
-    }
-    if (from && tx.from && !sameAddress(tx.from, from)) {
-      throw new Error(`protocol transaction ${index} sender mismatch`);
-    }
-    const guard = tx.slippageGuard || tx.madSlippage || route.autoSlippage || route.quote?.autoSlippage;
-    // Same bar as enforceTxPolicy sign/broadcast: a prepare helper must not
-    // become a second, softer gate that trusts caller-bound unsigned guards.
-    assertAutoSlippageGuard(guard, {
-      nowMs,
-      chainId,
-      venue: tx.to,
-      tx: { ...tx, chainId: Number(chainId), to: tx.to, data: tx.data },
-      requireSigned: true,
-    });
-    return {
-      chainId: Number(chainId),
-      to: tx.to,
-      data: tx.data,
-      value: tx.value == null ? "0x0" : String(tx.value),
-      ...(tx.gasLimit != null || tx.gas != null ? { gasLimit: String(tx.gasLimit ?? tx.gas) } : {}),
-      ...(tx.nonce != null ? { nonce: Number(tx.nonce) } : {}),
-      slippageGuard: guard,
-    };
-  });
-}

package/src/protocol-templates/gate.mjs

@@ -1,179 +0,0 @@
-// Protocol template security gate.
-// Refuse prepare-deploy unless Foundry tests are green.
-// Static analysis (slither) is required when available; otherwise documented skip.
-// This is NOT a substitute for a paid Solidity firm audit.
-
-import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createHash } from "node:crypto";
-
-const HERE = fileURLToPath(new URL(".", import.meta.url));
-const PKG_ROOT = resolve(HERE, "../..");
-const TEMPLATES_ROOT = join(PKG_ROOT, "protocols", "templates");
-
-export const TEMPLATE_AUDIT_DISCLAIMER =
-  "Template + Foundry tests + optional static analysis. NOT a paid security-firm audit. Do not put mainnet TVL on forks without an independent Solidity audit.";
-
-export function listProtocolTemplates() {
-  if (!existsSync(TEMPLATES_ROOT)) return [];
-  return readdirSync(TEMPLATES_ROOT)
-    .filter((name) => statSync(join(TEMPLATES_ROOT, name)).isDirectory())
-    .map((id) => {
-      const dir = join(TEMPLATES_ROOT, id);
-      const security = join(dir, "SECURITY.md");
-      return {
-        id,
-        path: dir,
-        securityNotice: existsSync(security) ? readFileSync(security, "utf8").slice(0, 500) : null,
-        disclaimer: TEMPLATE_AUDIT_DISCLAIMER,
-      };
-    });
-}
-
-function forgeBin() {
-  if (process.env.FORGE_BIN) return process.env.FORGE_BIN;
-  const home = process.env.HOME || "";
-  const candidates = ["forge", join(home, ".foundry/bin/forge")];
-  for (const c of candidates) {
-    const r = spawnSync(c, ["--version"], { encoding: "utf8" });
-    if (r.status === 0) return c;
-  }
-  return null;
-}
-
-function slitherBin() {
-  if (process.env.SLITHER_BIN) return process.env.SLITHER_BIN;
-  const r = spawnSync("slither", ["--version"], { encoding: "utf8" });
-  return r.status === 0 ? "slither" : null;
-}
-
-function run(cmd, args, cwd) {
-  const r = spawnSync(cmd, args, {
-    cwd,
-    encoding: "utf8",
-    env: { ...process.env, PATH: `${process.env.HOME || ""}/.foundry/bin:${process.env.PATH || ""}` },
-    timeout: 120_000,
-  });
-  return {
-    ok: r.status === 0,
-    status: r.status,
-    stdout: r.stdout || "",
-    stderr: r.stderr || "",
-  };
-}
-
-function hashTree(dir) {
-  const h = createHash("sha256");
-  function walk(p) {
-    const st = statSync(p);
-    if (st.isDirectory()) {
-      if (["lib", "out", "cache", ".git"].includes(p.split("/").pop())) return;
-      for (const name of readdirSync(p).sort()) walk(join(p, name));
-    } else if (st.isFile() && (p.endsWith(".sol") || p.endsWith(".toml") || p.endsWith(".md"))) {
-      h.update(p);
-      h.update(readFileSync(p));
-    }
-  }
-  walk(dir);
-  return h.digest("hex");
-}
-
-/**
- * Run security gate on a template id.
- * @param {string} templateId e.g. "safe-erc20"
- * @param {{ allowSkipStatic?: boolean }} opts
- */
-export function runProtocolTemplateGate(templateId, opts = {}) {
-  const allowSkipStatic = opts.allowSkipStatic !== false; // default allow skip if no slither
-  const dir = join(TEMPLATES_ROOT, templateId);
-  if (!existsSync(dir)) {
-    throw new Error(`protocol-templates: unknown template "${templateId}"`);
-  }
-
-  const forge = forgeBin();
-  if (!forge) {
-    throw new Error(
-      "protocol-templates: forge not found. Install Foundry (https://getfoundry.sh) then: cd protocols/templates/" +
-        templateId +
-        " && forge install && forge test"
-    );
-  }
-
-  // ensure libs (not vendored in git)
-  if (!existsSync(join(dir, "lib", "forge-std"))) {
-    const a = run(forge, ["install", "foundry-rs/forge-std", "--no-git"], dir);
-    if (!a.ok) throw new Error(`protocol-templates: forge install forge-std failed\n${a.stderr}`);
-  }
-  if (!existsSync(join(dir, "lib", "openzeppelin-contracts"))) {
-    const b = run(forge, ["install", "OpenZeppelin/openzeppelin-contracts@v5.0.2", "--no-git"], dir);
-    if (!b.ok) throw new Error(`protocol-templates: forge install openzeppelin failed\n${b.stderr}`);
-  }
-
-  const tests = run(forge, ["test", "-q"], dir);
-  if (!tests.ok) {
-    throw new Error(
-      `protocol-templates: forge test FAILED for ${templateId}\n${tests.stdout}\n${tests.stderr}`.slice(0, 2000)
-    );
-  }
-
-  let staticAnalysis = { tool: null, ok: true, skipped: true, reason: "slither not installed" };
-  const slither = slitherBin();
-  if (slither) {
-    const s = run(slither, [".", "--filter-paths", "lib", "--exclude-dependencies"], dir);
-    staticAnalysis = {
-      tool: "slither",
-      ok: s.ok,
-      skipped: false,
-      stdout: (s.stdout || "").slice(0, 1500),
-      stderr: (s.stderr || "").slice(0, 500),
-    };
-    if (!s.ok && !opts.allowStaticFail) {
-      throw new Error(`protocol-templates: slither FAILED for ${templateId}\n${s.stdout}\n${s.stderr}`.slice(0, 2000));
-    }
-  } else if (!allowSkipStatic) {
-    throw new Error("protocol-templates: slither required (allowSkipStatic=false) but not installed");
-  }
-
-  const sourceHash = hashTree(dir);
-  return {
-    ok: true,
-    templateId,
-    path: dir,
-    forgeTests: { ok: true, tool: "forge", summary: "forge test passed" },
-    staticAnalysis,
-    sourceHash,
-    disclaimer: TEMPLATE_AUDIT_DISCLAIMER,
-    firmAudit: false,
-  };
-}
-
-/**
- * Build artifact after gate. Returns bytecode for unsigned deploy prepare.
- */
-export function buildProtocolTemplate(templateId, opts = {}) {
-  const gate = runProtocolTemplateGate(templateId, opts);
-  const forge = forgeBin();
-  const dir = gate.path;
-  const build = run(forge, ["build", "-q"], dir);
-  if (!build.ok) {
-    throw new Error(`protocol-templates: forge build failed\n${build.stderr}`.slice(0, 1500));
-  }
-  // default contract name heuristic
-  const contractName = opts.contractName || (templateId === "safe-erc20" ? "SafeERC20" : null);
-  if (!contractName) throw new Error("protocol-templates: contractName required");
-  const artifactPath = join(dir, "out", `${contractName}.sol`, `${contractName}.json`);
-  if (!existsSync(artifactPath)) {
-    throw new Error(`protocol-templates: artifact missing at ${artifactPath}`);
-  }
-  const artifact = JSON.parse(readFileSync(artifactPath, "utf8"));
-  return {
-    gate,
-    contractName,
-    abi: artifact.abi,
-    bytecode: artifact.bytecode?.object || artifact.bytecode,
-    deployedBytecode: artifact.deployedBytecode?.object || artifact.deployedBytecode,
-    artifactPath,
-  };
-}

package/src/protocol-templates/prepare-deploy.mjs

@@ -1,81 +0,0 @@
-// Prepare unsigned deploy for a gated protocol template.
-// Never signs. Never broadcasts. Requires green forge tests first.
-
-import { ContractFactory, isAddress } from "ethers";
-import { stampPrepared } from "../prepare-envelope.mjs";
-import { buildProtocolTemplate, listProtocolTemplates, TEMPLATE_AUDIT_DISCLAIMER } from "./gate.mjs";
-
-export { listProtocolTemplates, TEMPLATE_AUDIT_DISCLAIMER };
-
-/**
- * @param {object} args
- * @param {string} args.templateId - e.g. safe-erc20
- * @param {number} args.chainId
- * @param {string[]} [args.constructorArgs] - ABI-encoded via ethers from values
- * @param {any[]} [args.args] - constructor JS values (preferred)
- * @param {string} [args.contractName]
- */
-export async function prepareTemplateDeploy(args = {}, opts = {}) {
-  const templateId = String(args.templateId || "").trim();
-  if (!templateId) throw new Error("prepareTemplateDeploy: templateId required");
-  const chainId = Number(args.chainId);
-  if (!Number.isInteger(chainId) || chainId <= 0) {
-    throw new Error("prepareTemplateDeploy: chainId required");
-  }
-
-  const built = buildProtocolTemplate(templateId, {
-    contractName: args.contractName,
-    allowSkipStatic: opts.allowSkipStatic !== false,
-    allowStaticFail: opts.allowStaticFail === true,
-  });
-
-  if (!built.bytecode || built.bytecode === "0x") {
-    throw new Error("prepareTemplateDeploy: empty bytecode");
-  }
-
-  const bc = built.bytecode.startsWith("0x") ? built.bytecode : `0x${built.bytecode}`;
-  const ctorArgs = args.args ?? args.constructorArgs ?? [];
-  const factory = new ContractFactory(built.abi, bc);
-  const deployTx = await factory.getDeployTransaction(...(Array.isArray(ctorArgs) ? ctorArgs : []));
-  const data = deployTx.data;
-
-  // validate SafeERC20 constructor shape if applicable
-  if (templateId === "safe-erc20" && Array.isArray(ctorArgs)) {
-    const [name, symbol, supply, holder, owner] = ctorArgs;
-    if (!name || !symbol) throw new Error("safe-erc20: name/symbol required");
-    if (supply == null || BigInt(supply) <= 0n) throw new Error("safe-erc20: supply must be > 0");
-    if (!isAddress(String(holder))) throw new Error("safe-erc20: initialHolder must be address");
-    if (!isAddress(String(owner))) throw new Error("safe-erc20: initialOwner must be address");
-  }
-
-  return stampPrepared(
-    {
-      provider: "protocol-templates",
-      kind: "template-deploy",
-      templateId,
-      contractName: built.contractName,
-      chainId,
-      transaction: {
-        chainId,
-        to: null, // creation
-        data,
-        value: "0x0",
-      },
-      abi: built.abi,
-      bytecodeHash: built.gate.sourceHash,
-      gate: {
-        forgeTests: built.gate.forgeTests,
-        staticAnalysis: {
-          tool: built.gate.staticAnalysis.tool,
-          ok: built.gate.staticAnalysis.ok,
-          skipped: built.gate.staticAnalysis.skipped,
-        },
-        firmAudit: false,
-        disclaimer: TEMPLATE_AUDIT_DISCLAIMER,
-      },
-      requiresUserSignature: true,
-      note: "Unsigned deploy. User wallet signs. Template tests passed; not a firm audit.",
-    },
-    { provider: "protocol-templates", kind: "template-deploy" }
-  );
-}