pub use super::formal_contract::*;
pub use crate::layer1::formal_witness::*;
#[cfg(feature = "native")]
mod native_exec {
use super::*;
use std::collections::{HashMap, HashSet};
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::{atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering}, mpsc, Arc};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
const MAX_FORMAL_OUTPUT_BYTES: usize = 1_048_576;
static WORK_DIR_SEQ: AtomicU64 = AtomicU64::new(0);
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct FormalDispatchOutcome {
pub exit_code: i32, pub stdout: String, pub stderr: String, pub witness: OracleWitness,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct FormalProbeReport {
pub runtime_id: String, pub profile_id: String, pub available: bool, pub timed_out: bool,
pub executable_path: Option<String>, pub toolchain_version: String, pub runner_used: bool,
}
enum BoundedRunOutcome { Completed { exit_code: i32, stdout: Vec<u8>, stderr: Vec<u8> }, TimedOut, OutputCapExceeded }
enum ProbeResolution { Found { exe_path: PathBuf, version_line: String, jar_path: Option<String> }, TimedOut, Unavailable }
fn kill_child_tree(child: &mut std::process::Child) {
#[cfg(unix)] { let _ = Command::new("/bin/kill").args(["-9", &format!("-{}", child.id())]).stdout(Stdio::null()).stderr(Stdio::null()).status(); }
let _ = child.kill(); let _ = child.wait();
}
fn spawn_reader<R: Read + Send + 'static>(mut stream: R, total: Arc<AtomicUsize>, exceeded: Arc<AtomicBool>, cap: usize) -> mpsc::Receiver<Vec<u8>> {
let (tx, rx) = mpsc::sync_channel(1);
std::thread::spawn(move || {
let (mut buf, mut chunk) = (Vec::new(), [0u8; 8192]);
while let Ok(n) = stream.read(&mut chunk) {
if n == 0 { break; }
if total.fetch_add(n, Ordering::SeqCst) + n > cap { exceeded.store(true, Ordering::SeqCst); break; }
buf.extend_from_slice(&chunk[..n]);
}
let _ = tx.send(buf);
});
rx
}
fn spawn_bounded(
executable: &Path, args: &[String], cwd: Option<&Path>, env: &HashMap<String, String>,
stdin_bytes: Option<&[u8]>, timeout_ms: u64, max_output_bytes: usize,
) -> Result<BoundedRunOutcome, String> {
let mut cmd = Command::new(executable);
cmd.args(args).env_clear().envs(env).stdout(Stdio::piped()).stderr(Stdio::piped());
cmd.stdin(if stdin_bytes.is_some() { Stdio::piped() } else { Stdio::null() });
if let Some(dir) = cwd { cmd.current_dir(dir); }
#[cfg(unix)]
{ use std::os::unix::process::CommandExt; cmd.process_group(0); }
let mut child = cmd.spawn().map_err(|e| format!("Failed to spawn {}: {}", executable.display(), e))?;
if let (Some(bytes), Some(mut child_in)) = (stdin_bytes.map(|b| b.to_vec()), child.stdin.take()) {
std::thread::spawn(move || { let _ = child_in.write_all(&bytes); });
}
let (total, exceeded) = (Arc::new(AtomicUsize::new(0)), Arc::new(AtomicBool::new(false)));
let out_rx = spawn_reader(child.stdout.take().unwrap(), Arc::clone(&total), Arc::clone(&exceeded), max_output_bytes);
let err_rx = spawn_reader(child.stderr.take().unwrap(), Arc::clone(&total), Arc::clone(&exceeded), max_output_bytes);
let deadline = Instant::now() + Duration::from_millis(timeout_ms);
loop {
if exceeded.load(Ordering::SeqCst) { kill_child_tree(&mut child); return Ok(BoundedRunOutcome::OutputCapExceeded); }
if let Some(status) = child.try_wait().map_err(|e| e.to_string())? {
let stdout = out_rx.recv_timeout(Duration::from_millis(250)).unwrap_or_default();
let stderr = err_rx.recv_timeout(Duration::from_millis(250)).unwrap_or_default();
if exceeded.load(Ordering::SeqCst) || stdout.len() + stderr.len() > max_output_bytes {
return Ok(BoundedRunOutcome::OutputCapExceeded);
}
return Ok(BoundedRunOutcome::Completed { exit_code: status.code().unwrap_or(1), stdout, stderr });
}
if Instant::now() >= deadline { kill_child_tree(&mut child); return Ok(BoundedRunOutcome::TimedOut); }
std::thread::sleep(Duration::from_millis(5));
}
}
fn candidate_search_dirs(sanitized_env: &HashMap<String, String>, include_fallbacks: bool) -> Vec<PathBuf> {
let mut raw = Vec::new();
if let Some(p) = sanitized_env.get("PATH") { raw.extend(std::env::split_paths(p).filter(|d| !d.as_os_str().is_empty())); }
if let Some(elan) = sanitized_env.get("ELAN_HOME") { raw.push(PathBuf::from(elan).join("bin")); }
if let Some(jh) = sanitized_env.get("JAVA_HOME") { raw.push(PathBuf::from(jh).join("bin")); }
if include_fallbacks {
let home = sanitized_env.get("HOME").map(PathBuf::from).or_else(|| crate::layer0::environment::var_os("HOME").map(PathBuf::from));
if let Some(ref h) = home {
raw.push(h.join(".elan/bin"));
if let Ok(entries) = std::fs::read_dir(h.join(".opam")) {
let mut sw: Vec<PathBuf> = entries.flatten().map(|e| e.path().join("bin")).filter(|p| p.is_dir()).collect();
sw.sort();
raw.extend(sw);
}
}
raw.push(PathBuf::from("/opt/homebrew/bin"));
if let Some(ref h) = home { raw.push(h.join(".local/bin")); }
}
let mut seen = HashSet::new();
raw.into_iter().filter(|d| seen.insert(d.clone())).collect()
}
fn is_platform_triple_token(token: &str) -> bool {
let valid_tail = |seg: &str| {
!seg.is_empty()
&& seg.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_' || c == '.')
};
let mut parts = token.split('-');
let Some(first) = parts.next() else { return false };
let mut first_chars = first.chars();
if !first_chars.next().is_some_and(|c| c.is_ascii_lowercase())
|| !first_chars.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
{
return false;
}
if !parts.next().is_some_and(valid_tail) || !parts.next().is_some_and(valid_tail) {
return false;
}
match parts.next() {
None => true,
Some(fourth) => valid_tail(fourth) && parts.next().is_none(),
}
}
fn normalize_toolchain_version(line: &str) -> String {
let mut out = String::with_capacity(line.len());
let mut iter = line.char_indices().peekable();
let mut copied = 0;
let mut changed = false;
while let Some((comma_idx, ch)) = iter.next() {
if ch == ',' && iter.peek().is_some_and(|&(_, next_ch)| next_ch == ' ') {
iter.next();
let Some(&(token_start, _)) = iter.peek() else { break };
let tail = &line[token_start..];
if let Some((rel_end, delim)) = tail
.char_indices()
.find(|&(_, c)| c == ',' || c == ')' || c == ' ')
{
if (delim == ',' || delim == ')') && is_platform_triple_token(&tail[..rel_end]) {
out.push_str(&line[copied..comma_idx]);
let delim_idx = token_start + rel_end;
copied = delim_idx;
changed = true;
while iter.peek().is_some_and(|&(idx, _)| idx < delim_idx) {
iter.next();
}
}
}
}
}
if !changed {
return line.to_string();
}
out.push_str(&line[copied..]);
out
}
fn probe_matches(
cand: &Path, args: &[String], allow_nonzero: bool, subs_all: &[String], subs_any: &[String],
env: &HashMap<String, String>, timeout_ms: u64,
) -> Result<Option<String>, ()> {
let probe_cwd = std::env::temp_dir();
match spawn_bounded(cand, args, Some(&probe_cwd), env, None, timeout_ms, MAX_FORMAL_OUTPUT_BYTES) {
Ok(BoundedRunOutcome::TimedOut) => Err(()),
Ok(BoundedRunOutcome::Completed { exit_code, stdout, stderr }) if allow_nonzero || exit_code == 0 => {
let combined = format!("{}\n{}", String::from_utf8_lossy(&stdout), String::from_utf8_lossy(&stderr));
if subs_all.iter().all(|s| combined.contains(s)) && (subs_any.is_empty() || subs_any.iter().any(|s| combined.contains(s))) {
return Ok(Some(normalize_toolchain_version(combined.lines().find(|l| !l.trim().is_empty()).unwrap_or("").trim())));
}
Ok(None)
}
_ => Ok(None),
}
}
fn scan_dirs_for_exe(dirs: &[PathBuf], exe: &str, args: &[String], nz: bool, sall: &[String], sany: &[String], env: &HashMap<String, String>, tms: u64) -> Result<Option<(PathBuf, String)>, ()> {
for dir in dirs {
let cand = dir.join(exe);
if cand.is_file() { if let Some(ver) = probe_matches(&cand, args, nz, sall, sany, env, tms)? { return Ok(Some((cand, ver))); } }
}
Ok(None)
}
fn resolve_toolchain(target: &ResolvedFormalTarget, sanitized_env: &HashMap<String, String>, include_fallbacks: bool) -> ProbeResolution {
let dirs = candidate_search_dirs(sanitized_env, include_fallbacks);
match scan_dirs_for_exe(&dirs, &target.executable, &target.probe_args, target.allow_nonzero_probe, &target.version_substrings_all, &target.version_substrings_any, sanitized_env, target.probe_timeout_ms) {
Err(()) => return ProbeResolution::TimedOut,
Ok(Some((exe_path, version_line))) => return ProbeResolution::Found { exe_path, version_line, jar_path: None },
Ok(None) => {}
}
let Some(ref runner) = target.runner else { return ProbeResolution::Unavailable; };
let home = sanitized_env.get("HOME").map(PathBuf::from).or_else(|| if include_fallbacks { crate::layer0::environment::var_os("HOME").map(PathBuf::from) } else { None });
let jar_opt = sanitized_env.get("TLA2TOOLS_JAR").map(PathBuf::from).filter(|p| p.is_file())
.or_else(|| target.default_jar_relpath.as_ref().and_then(|rel| home.as_ref().map(|h| h.join(rel))).filter(|p| p.is_file()))
.or_else(|| home.as_ref().map(|h| h.join(".local/share/tlaplus/tla2tools-1.8.0.jar")).filter(|p| p.is_file()));
let (Some(jar_path), Some(rt_lock)) = (jar_opt, target.lock_runtimes.get(&runner.runtime_id)) else { return ProbeResolution::Unavailable; };
let Some(profs_obj) = rt_lock.get("profiles").and_then(|v| v.as_object()) else { return ProbeResolution::Unavailable; };
let def_p = rt_lock.get("default_profile").and_then(|v| v.as_str()).unwrap_or_default();
let mut order: Vec<&str> = if profs_obj.contains_key(def_p) { vec![def_p] } else { Vec::new() };
order.extend(profs_obj.keys().map(String::as_str).filter(|k| *k != def_p));
let mut java_exe = None;
for pk in order {
let pl = &profs_obj[pk];
let exe = pl.get("executable").and_then(|v| v.as_str()).unwrap_or_default();
match scan_dirs_for_exe(&dirs, exe, &json_str_vec(pl.get("probe_args")), pl.get("allow_nonzero_probe").and_then(|v| v.as_bool()).unwrap_or(false), &json_str_vec(pl.get("version_substrings_all")), &json_str_vec(pl.get("version_substrings_any")), sanitized_env, target.probe_timeout_ms) {
Err(()) => return ProbeResolution::TimedOut,
Ok(Some((cand, _))) => { java_exe = Some(cand); break; }
Ok(None) => {}
}
}
let Some(j_exe) = java_exe else { return ProbeResolution::Unavailable; };
let jar_str = jar_path.to_string_lossy().into_owned();
let jar_args = vec!["-cp".to_string(), jar_str.clone(), "tlc2.TLC".to_string(), "-version".to_string()];
match probe_matches(&j_exe, &jar_args, target.allow_nonzero_probe, &target.version_substrings_all, &target.version_substrings_any, sanitized_env, target.probe_timeout_ms) {
Err(()) => ProbeResolution::TimedOut,
Ok(Some(version_line)) => ProbeResolution::Found { exe_path: j_exe, version_line, jar_path: Some(jar_str) },
Ok(None) => ProbeResolution::Unavailable,
}
}
fn seal_outcome(t: &ResolvedFormalTarget, status: OracleWitnessStatus, source_digest: String, theorem_digest: String, toolchain_version: String, argv: Vec<String>, result_digest: String, diagnostic_digest: String, stderr: String) -> FormalDispatchOutcome {
let exit_code = match status { OracleWitnessStatus::Verified | OracleWitnessStatus::SkippedUnavailable => 0, _ => 1 };
let witness = build_oracle_witness(OracleWitnessInput { runtime_id: t.canonical_id.clone(), profile_id: t.active_profile.clone(), status, source_digest, theorem_digest, toolchain_version, argv, env_allowlist: t.env_allowlist.clone(), result_digest, diagnostic_digest });
FormalDispatchOutcome { exit_code, stdout: serde_json::to_string(&witness).unwrap_or_default(), stderr, witness }
}
fn seal_terminal(t: &ResolvedFormalTarget, st: OracleWitnessStatus, sd: String, td: String, ver: String, argv: Vec<String>, tag: &str) -> FormalDispatchOutcome {
seal_outcome(t, st, sd, td, ver, argv, compute_formal_blake3(b""), compute_formal_blake3(tag.as_bytes()), tag.to_string())
}
pub fn list_formal_runtimes(explicit_clm_root: &str) -> Result<Vec<FormalRuntimeSummary>, String> {
load_formal_runtime_summaries(explicit_clm_root)
}
pub fn probe_formal_runtime(
runtime_id: &str, profile_id: Option<&str>, caller_env: Option<&HashMap<String, String>>,
include_system_fallbacks: bool, explicit_clm_root: &str,
) -> Result<FormalProbeReport, String> {
let target = resolve_formal_target(runtime_id, profile_id, None, None, explicit_clm_root)?;
let (sanitized_env, _) = sanitize_env_and_strict(false, false, &target.env_allowlist, caller_env);
let (available, timed_out, executable_path, toolchain_version, runner_used) = match resolve_toolchain(&target, &sanitized_env, include_system_fallbacks) {
ProbeResolution::Found { exe_path, version_line, jar_path } => (true, false, Some(exe_path.to_string_lossy().into_owned()), version_line, jar_path.is_some()),
ProbeResolution::TimedOut => (false, true, None, "timeout".to_string(), false),
ProbeResolution::Unavailable => (false, false, None, "unavailable".to_string(), false),
};
Ok(FormalProbeReport {
runtime_id: target.canonical_id, profile_id: target.active_profile, available, timed_out,
executable_path, toolchain_version, runner_used,
})
}
pub fn execute_formal_request(
request: &FormalExecutionRequest, caller_env: Option<&HashMap<String, String>>,
) -> Result<FormalDispatchOutcome, String> {
let target = resolve_formal_target(&request.runtime_id, request.profile_id.as_deref(), request.timeout_ms, request.probe_timeout_ms, &request.clm_root)?;
if let Some(bad) = request.staged_files.keys().find(|k| !is_bare_filename(k)) {
return Err(format!("Invalid staged_files key: {}", bad));
}
if request.source_file.as_deref().is_some_and(|s| !s.is_empty()) == request.source_text.is_some() {
return Err("Provide exactly one of source_file or source_text".to_string());
}
let (sanitized_env, is_strict) = sanitize_env_and_strict(request.strict, request.isolated_empty_path, &target.env_allowlist, caller_env);
let resolve_rel = |raw: &str| -> PathBuf {
let p = Path::new(raw);
if p.is_absolute() || (!target.clm_root.join(p).is_file() && p.is_file()) { p.to_path_buf() } else { target.clm_root.join(p) }
};
let (staged_basename, raw_bytes, sf_disk_opt) = if let Some(sf_str) = request.source_file.as_deref().filter(|s| !s.is_empty()) {
let base = Path::new(sf_str).file_name().and_then(|n| n.to_str()).filter(|n| is_bare_filename(n))
.ok_or_else(|| format!("Invalid source_file basename: {}", sf_str))?.to_string();
let sf_path = resolve_rel(sf_str);
if !sf_path.is_file() {
let (empty_dig, stem) = (compute_formal_blake3(b""), file_stem_label(&base));
let thm_lbl = request.theorem_name.as_deref().filter(|s| !s.is_empty()).unwrap_or(&stem);
let thm_dig = compute_formal_blake3(format!("{}:{}:{}:{}", target.canonical_id, target.active_profile, thm_lbl, empty_dig).as_bytes());
let ep = request.entry_point.as_deref().filter(|s| !s.is_empty()).unwrap_or(&stem);
let argv = expand_canonical_argv(&target.argv_template, &target.config_args_template, &base, ep, None, None, &request.extra_args, &request.trailing_args);
return Ok(seal_terminal(&target, OracleWitnessStatus::Refuted, empty_dig, thm_dig, "missing_source".to_string(), argv, "source_file_missing"));
}
(base, std::fs::read(&sf_path).map_err(|e| e.to_string())?, Some(sf_path))
} else {
let sn = request.source_name.as_deref().filter(|n| is_bare_filename(n))
.ok_or_else(|| "source_name must be a valid bare filename when source_text is supplied".to_string())?;
(sn.to_string(), request.source_text.as_deref().unwrap_or_default().as_bytes().to_vec(), None)
};
let stem = file_stem_label(&staged_basename);
let thm_lbl = request.theorem_name.as_deref().filter(|s| !s.is_empty()).unwrap_or(&stem);
let source_digest = compute_formal_blake3(&raw_bytes);
let theorem_digest = compute_formal_blake3(format!("{}:{}:{}:{}", target.canonical_id, target.active_profile, thm_lbl, source_digest).as_bytes());
let (staged_cfg_name, cfg_disk_path) = if let Some(cf) = request.config_file.as_deref().filter(|s| !s.is_empty()) {
let cf_base = Path::new(cf).file_name().and_then(|n| n.to_str()).unwrap_or_default();
if !cf_base.is_empty() && request.staged_files.contains_key(cf_base) { (Some(cf_base.to_string()), None) }
else { let cp = resolve_rel(cf); if cp.is_file() { (cp.file_name().and_then(|n| n.to_str()).map(String::from), Some(cp)) } else { (None, None) } }
} else if let Some(sib) = sf_disk_opt.as_ref().map(|p| p.with_extension("cfg")).filter(|p| p.is_file()) {
(sib.file_name().and_then(|n| n.to_str()).map(String::from), Some(sib))
} else { (None, None) };
let entry_pt = request.entry_point.as_deref().filter(|s| !s.is_empty()).unwrap_or(&stem);
let mut canonical_argv = expand_canonical_argv(&target.argv_template, &target.config_args_template, &staged_basename, entry_pt, staged_cfg_name.as_deref(), None, &request.extra_args, &request.trailing_args);
let (exe_path, version_line, active_tpl) = match resolve_toolchain(&target, &sanitized_env, request.include_system_fallbacks && !request.isolated_empty_path) {
ProbeResolution::TimedOut => return Ok(seal_terminal(&target, OracleWitnessStatus::Refuted, source_digest, theorem_digest, "timeout".to_string(), canonical_argv, "timeout")),
ProbeResolution::Unavailable => {
let st = if is_strict { OracleWitnessStatus::Refuted } else { OracleWitnessStatus::SkippedUnavailable };
return Ok(seal_terminal(&target, st, source_digest, theorem_digest, "unavailable".to_string(), canonical_argv, "toolchain_unavailable"));
}
ProbeResolution::Found { exe_path, version_line, jar_path } => {
if let (Some(jar), Some(runner)) = (jar_path.as_deref(), target.runner.as_ref()) {
canonical_argv = expand_canonical_argv(&runner.argv_template, &target.config_args_template, &staged_basename, entry_pt, staged_cfg_name.as_deref(), Some(jar), &request.extra_args, &request.trailing_args);
(exe_path, version_line, &runner.argv_template)
} else { (exe_path, version_line, &target.argv_template) }
}
};
let nonce = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or(0);
let work_dir = std::env::temp_dir().join(format!("clm_formal_{}_{}_{}", std::process::id(), nonce, WORK_DIR_SEQ.fetch_add(1, Ordering::Relaxed)));
std::fs::create_dir_all(&work_dir).map_err(|e| e.to_string())?;
std::fs::write(work_dir.join(&staged_basename), &raw_bytes).map_err(|e| e.to_string())?;
for (fname, body) in &request.staged_files { std::fs::write(work_dir.join(fname), body.as_bytes()).map_err(|e| e.to_string())?; }
if let (Some(cfg_n), Some(cfg_p)) = (staged_cfg_name.as_deref(), cfg_disk_path.as_deref()) {
if !request.staged_files.contains_key(cfg_n) { std::fs::copy(cfg_p, work_dir.join(cfg_n)).map_err(|e| e.to_string())?; }
}
if active_tpl.iter().any(|t| t.contains("{output_dir}")) { std::fs::create_dir_all(work_dir.join("classes")).map_err(|e| e.to_string())?; }
let real_work = std::fs::canonicalize(&work_dir).map(|p| p.to_string_lossy().into_owned()).unwrap_or_default();
let raw_work = work_dir.to_string_lossy().into_owned();
let run_res = spawn_bounded(&exe_path, &canonical_argv[1..], Some(&work_dir), &sanitized_env, request.stdin_text.as_deref().map(str::as_bytes), target.timeout_ms, MAX_FORMAL_OUTPUT_BYTES);
let _ = std::fs::remove_dir_all(&work_dir);
match run_res? {
BoundedRunOutcome::TimedOut => Ok(seal_terminal(&target, OracleWitnessStatus::Refuted, source_digest, theorem_digest, version_line, canonical_argv, "timeout")),
BoundedRunOutcome::OutputCapExceeded => Ok(seal_terminal(&target, OracleWitnessStatus::Refuted, source_digest, theorem_digest, version_line, canonical_argv, "output_cap_exceeded")),
BoundedRunOutcome::Completed { exit_code, stdout, stderr } => {
let norm_out = normalize_formal_output(&String::from_utf8_lossy(&stdout), &real_work, &raw_work, &target.nondeterministic_line_patterns, &target.nondeterministic_inline_patterns)?;
let norm_err = normalize_formal_output(&String::from_utf8_lossy(&stderr), &real_work, &raw_work, &target.nondeterministic_line_patterns, &target.nondeterministic_inline_patterns)?;
let accepted = evaluate_accept_predicate(&target.accept_predicate, exit_code, &norm_out, &norm_err, &String::from_utf8_lossy(&raw_bytes))?;
let status = if accepted { OracleWitnessStatus::Verified } else { OracleWitnessStatus::Refuted };
let (res_dig, diag_dig) = (compute_formal_blake3(norm_out.as_bytes()), compute_formal_blake3(format!("{}\n{}", norm_out, norm_err).as_bytes()));
Ok(seal_outcome(&target, status, source_digest, theorem_digest, version_line, canonical_argv, res_dig, diag_dig, if norm_err.is_empty() { norm_out } else { norm_err }))
}
}
}
pub fn dispatch_formal_runtime_script(
runtime_alias: &str, script: &str, profile_override: &str, extra_args: &[String],
caller_env: &HashMap<String, String>, explicit_clm_root: &str,
) -> Result<FormalDispatchOutcome, String> {
let target = resolve_formal_target(runtime_alias, Some(profile_override).filter(|s| !s.is_empty()), None, None, explicit_clm_root)?;
let (source_file, source_text, source_name, rem_args) = if !script.is_empty() {
(None, Some(script.to_string()), Some(format!("Spec{}", target.default_extension)), extra_args.to_vec())
} else if let Some((first, rest)) = extra_args.split_first() {
(Some(first.clone()), None, None, rest.to_vec())
} else {
return Err("Formal oracle requires script content or source file path".to_string());
};
let req = FormalExecutionRequest {
runtime_id: runtime_alias.to_string(),
profile_id: if profile_override.is_empty() { None } else { Some(profile_override.to_string()) },
source_file, source_text, source_name, extra_args: rem_args,
clm_root: explicit_clm_root.to_string(), ..Default::default()
};
execute_formal_request(&req, if caller_env.is_empty() { None } else { Some(caller_env) })
}
}
#[cfg(feature = "native")]
pub use native_exec::*;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_oracle_witness_four_state() {
let golden = build_oracle_witness(OracleWitnessInput {
runtime_id: "lean".to_string(), profile_id: "lean_4_35".to_string(), status: OracleWitnessStatus::Verified,
source_digest: "blake3:1111111111111111111111111111111111111111111111111111111111111111".to_string(),
theorem_digest: "blake3:2222222222222222222222222222222222222222222222222222222222222222".to_string(),
toolchain_version: "Lean (version 4.35.0)".to_string(),
argv: vec!["lean".to_string(), "--json".to_string(), "OpenPetriPullback.lean".to_string()],
env_allowlist: vec!["PATH".to_string(), "HOME".to_string(), "ELAN_HOME".to_string()],
result_digest: "blake3:3333333333333333333333333333333333333333333333333333333333333333".to_string(),
diagnostic_digest: "blake3:4444444444444444444444444444444444444444444444444444444444444444".to_string(),
});
assert_eq!(golden.witness_digest, "blake3:5e8e01eca1a2620549b6af9e9345c15ffba6c960f587ac0b9ec929b6b0b07b62");
assert_eq!(compute_formal_blake3(&vec![b'A'; 3000]), "blake3:7b3b0f7dbb4d47318d00886cdae41ed2886dcaed7b6840372f9e570939f151ec");
assert_eq!(verify_oracle_witness(&golden, None), OracleWitnessStatus::Verified);
let stale_exp = WitnessFreshnessExpectation {
source_digest: Some("blake3:9999999999999999999999999999999999999999999999999999999999999999".to_string()),
theorem_digest: None, toolchain_version: None,
};
assert_eq!(verify_oracle_witness(&golden, Some(&stale_exp)), OracleWitnessStatus::StaleWitness);
let skipped = build_oracle_witness(OracleWitnessInput {
runtime_id: golden.runtime_id.clone(), profile_id: golden.profile_id.clone(), status: OracleWitnessStatus::SkippedUnavailable,
source_digest: golden.source_digest.clone(), theorem_digest: golden.theorem_digest.clone(),
toolchain_version: golden.toolchain_version.clone(), argv: golden.argv.clone(),
env_allowlist: golden.env_allowlist.clone(), result_digest: golden.result_digest.clone(),
diagnostic_digest: golden.diagnostic_digest.clone(),
});
assert_eq!(verify_oracle_witness(&skipped, None), OracleWitnessStatus::SkippedUnavailable);
let mut tampered = golden.clone();
tampered.toolchain_version = "Lean (version 4.99.0)".to_string();
assert_eq!(verify_oracle_witness(&tampered, None), OracleWitnessStatus::Refuted);
}
}