fix: sp1 abort reason via public values stream

Author: Marcos Pernambuco Motta

sp1/README.md

@@ -103,9 +103,10 @@ Sepolia gateway; nothing in this repo commits to either choice.
     make -C sp1 seal           # prove the one-mcycle fixture to a Groth16 seal
     make -C sp1 test-solidity  # on-chain tests against a Sepolia fork (needs seal)
 
-The reject-fixture tests run the CLI as a subprocess and assert the abort
-reason each forged log dies with. They execute without proving, so no GPU
-and no artifact download is needed.
+The reject-fixture tests assert the abort reason each forged log dies with;
+the guest writes it to the public-values stream, the one channel every
+executor backend carries back to the host. They execute without proving, so
+no GPU and no artifact download is needed.
 
 ## The sha256 precompile ABI
 

sp1/cpp/sp1-runtime.cpp

@@ -23,6 +23,7 @@
 // SP1 runtime primitives from libzkevm.a
 extern "C" void syscall_write(uint32_t fd, const uint8_t *buf, size_t nbytes);
 extern "C" NO_RETURN void syscall_halt(uint8_t exit_code);
+extern "C" void write_output(const uint8_t *output, size_t size);
 // On the RV64 target the sha256 precompiles address w and state with an 8-byte
 // stride: 64 and 8 u64 slots each holding a u32 value (see sp1-core-executor
 // minimal/precompiles/sha256). A u32-packed buffer overruns.
@@ -58,8 +59,13 @@ extern "C" void zk_putchar(char character) {
 
 // abort() itself comes from libzkevm.a; assert() in zk-runtime.hpp calls it.
 
+// The reason goes to the public-values stream as well as stderr: the stream
+// travels back to the host on every executor backend, while stderr forwarding
+// does not (the x86-64 native executor drops it). A nonzero halt is never
+// proven, so the stream carries no committed meaning on this path.
 extern "C" NO_RETURN void zk_abort_with_msg(const char *msg) {
     syscall_write(2, reinterpret_cast<const uint8_t *>(msg), strlen(msg));
+    write_output(reinterpret_cast<const uint8_t *>(msg), strlen(msg));
     syscall_halt(1);
 }
 

sp1/rust/src/lib.rs

@@ -120,8 +120,10 @@ pub fn stdin_for_log(log_file_path: &str) -> Result<SP1Stdin, String> {
 ///
 /// The exit code check is not optional. A structurally invalid log makes the
 /// guest abort via `zk_abort_with_msg`, which halts with code 1, but SP1's
-/// executor returns `Ok` for a nonzero halt: only the abort message reaches the
-/// process stderr. Without this check a forged log reads as accepted.
+/// executor returns `Ok` for a nonzero halt. The abort reason is read from the
+/// public-values stream, where the guest writes it alongside stderr: the
+/// stream comes back on every executor backend, while stderr forwarding does
+/// not (the x86-64 native executor drops it).
 pub async fn try_execute<P: Prover>(
     client: &P,
     elf: Elf,
@@ -133,7 +135,11 @@ pub async fn try_execute<P: Prover>(
         .await
         .map_err(|e| format!("{e}"))?;
     if report.exit_code != 0 {
-        return Err(format!("guest aborted with exit code {}", report.exit_code));
+        let reason = String::from_utf8_lossy(public_values.as_slice());
+        return Err(format!(
+            "guest aborted with exit code {}: {reason}",
+            report.exit_code
+        ));
     }
     Ok((public_values, report))
 }

sp1/rust/tests/test_reject_fixtures.rs

@@ -18,12 +18,13 @@
 //! log. The reject fixtures are structurally invalid step logs and the guest
 //! must abort on every one, each for its own reason.
 //!
-//! The abort reason only surfaces on the process stderr, so the reject
-//! assertions run the CLI as a subprocess and match the reason there.
+//! The reason arrives through the public-values stream (surfaced in
+//! try_execute's error), the one channel every executor backend carries —
+//! stderr forwarding is interpreter-only.
 //!
 //! Generate the fixtures with `make -C sp1 fixtures` (needs a built emulator).
 
-use std::{fs, path::PathBuf, process::Command};
+use std::{fs, path::PathBuf};
 
 use cartesi_sp1::try_execute;
 use sp1_sdk::{Elf, ProverClient};
@@ -69,8 +70,8 @@ fn guest_elf() -> Elf {
     Elf::Static(Box::leak(bytes.into_boxed_slice()))
 }
 
-#[test]
-fn guest_rejects_forged_logs() {
+#[tokio::test]
+async fn guest_rejects_forged_logs() {
     let dir = fixtures_dir().join("reject-machine");
     assert!(
         dir.exists(),
@@ -80,8 +81,8 @@ fn guest_rejects_forged_logs() {
     let text = fs::read_to_string(dir.join("_manifest.csv"))
         .unwrap_or_else(|e| panic!("failed to read reject manifest: {e}"));
 
-    let cli = env!("CARGO_BIN_EXE_cartesi-sp1-cli");
-    let guest = repo_root().join("sp1/cpp/guest.elf");
+    let client = ProverClient::builder().light().build().await;
+    let elf = guest_elf();
     let mut checked = 0;
     for line in text.lines().skip(1) {
         if line.is_empty() {
@@ -96,21 +97,15 @@ fn guest_rejects_forged_logs() {
         let (name, tag) = (cols[1], cols[2]);
         let path = dir.join(name);
 
-        let output = Command::new(cli)
-            .args(["--guest-elf", guest.to_str().unwrap()])
-            .args(["execute", path.to_str().unwrap()])
-            .output()
-            .unwrap_or_else(|e| panic!("running {cli}: {e}"));
-        assert!(
-            !output.status.success(),
-            "guest ACCEPTED forged log {name} (tag {tag})"
-        );
-        let stderr = String::from_utf8_lossy(&output.stderr);
+        let error = try_execute(&client, elf.clone(), path.to_str().unwrap())
+            .await
+            .err()
+            .unwrap_or_else(|| panic!("guest ACCEPTED forged log {name} (tag {tag})"));
         let expected = expected_message(tag);
         assert!(
-            stderr.contains(expected),
+            error.contains(expected),
             "forged log {name} (tag {tag}) rejected for the wrong reason:\n  \
-             expected substring {expected:?}\n  stderr: {stderr}"
+             expected substring {expected:?}\n  error: {error}"
         );
         checked += 1;
     }