starknet_os_flow_tests: add repro test for privacy-prove keccak builtin failure

Adds an `#[ignore]`-gated test, `prove_and_verify_keccak_tx`, that deterministically
reproduces a `privacy-prove` proving failure when a virtual OS PIE contains keccak
builtin usage from a user contract. OS execution succeeds; the failure is in the
privacy bootloader's `load_cairo_pie` hint relocating the inner PIE memory.

See REPRO_KECCAK_PRIVACY_PROVE.md for run instructions, observed failure output,
suspected root cause (`stwo_no_ecop` layout excludes keccak), and the isolation
experiment confirming the failure is triggered by the keccak BUILTIN, not the
keccak SYSCALL.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Yoni-Starkware

Cargo.lock

@@ -0,0 +1,92 @@
+# Repro: privacy-prove fails on virtual OS PIE that uses keccak builtin
+
+This branch carries an `#[ignore]`-gated integration test that demonstrates a
+deterministic proving failure in `privacy-prove` when the inner task (a Starknet
+virtual OS run) contains keccak builtin usage by a user contract.
+
+The keccak **syscall** in the virtual OS is **not** the cause — that path proves
+fine. The failure is triggered by the keccak **builtin** appearing in the OS PIE.
+
+## Test
+
+`crates/starknet_os_flow_tests/src/virtual_os_test.rs::prove_and_verify_keccak_tx`
+
+It invokes `test_contract::test_keccak`, which exercises both the keccak builtin
+(`keccak::keccak_u256s_le_inputs`) and the keccak syscall (failure path with an
+invalid length).
+
+## How to run
+
+Requires the project's Python venv (for the Cairo 0 compiler) and the
+nightly Rust toolchain that the prover crate needs.
+
+```bash
+# From the repo root:
+source sequencer_venv/bin/activate
+
+cargo +nightly-2025-07-14 test \
+    -p starknet_os_flow_tests \
+    --features starknet_transaction_prover/stwo_proving \
+    --release \
+    prove_and_verify_keccak_tx \
+    -- --ignored --nocapture
+```
+
+First run cold-builds the workspace in release mode (~5 min on a fast
+machine); subsequent runs are fast. The test itself runs the OS, proves, and
+verifies in ~40 s once built.
+
+## Observed failure
+
+```
+thread 'virtual_os_test::prove_and_verify_keccak_tx' panicked at
+crates/starknet_os_flow_tests/src/virtual_os_test_manager.rs:42:53:
+Proving virtual OS should not fail.:
+ProvingError(ProverExecution(
+  ".../simple_bootloader/execute_task.cairo:209:5: Error at pc=0:615:
+  Got an exception while executing a hint: Hint Error:
+  Error while relocating Cairo PIE memory: Memory addresses must be relocatable
+  Cairo traceback (most recent call last):
+  <start>:3:1: (pc=0:2)
+  .../simple_bootloader/privacy_simple_bootloader.cairo:109:5: (pc=0:1116)
+  .../simple_bootloader/run_simple_bootloader.cairo:114:9: (pc=0:727)
+  .../simple_bootloader/run_simple_bootloader.cairo:199:5: (pc=0:782)"
+))
+```
+
+OS execution succeeds — the failure is strictly in the proving step.
+
+## Suspected root cause
+
+1. `privacy_prove::consts::CAIRO_RUN_CONFIG` (`crates/privacy_prove/src/consts.rs`
+   in `proving-utils` rev `580135e`) selects `LayoutName::stwo_no_ecop`.
+2. `BuiltinsInstanceDef::stwo_no_ecop()` in `cairo-vm-3.2.0` returns
+   `keccak: None, ecdsa: None, ec_op: None`.
+3. The privacy bootloader's `simple_bootloader_simulate_keccak` hint installs an
+   auto-deduction-rule-based simulated keccak segment, but the relocation logic
+   in
+   `cairo-program-runner-lib::hints::load_cairo_pie::build_cairo_pie_relocation_table`
+   reads `cairo_pie_execution_segment[idx]` for each declared builtin and
+   `extract_segment`s a relocatable from it. When the inner OS PIE has actually
+   exercised keccak (so the keccak builtin segment in the PIE is non-empty), the
+   value found at that cell is a felt (Int), not a relocatable, and
+   `extract_segment` returns `MemoryError::AddressNotRelocatable`.
+
+## Isolation experiment (already verified locally)
+
+Comment out the keccak BUILTIN call inside
+`crates/blockifier_test_utils/resources/feature_contracts/cairo1/test_contract.cairo::test_keccak`
+(the `keccak::keccak_u256s_le_inputs(...)` block, lines ~642–647 on this branch),
+leaving only the keccak SYSCALL failure-path call. Re-run the same command — the
+test now proves and verifies cleanly. This confirms the failure is exercised by
+the keccak BUILTIN, not the SYSCALL.
+
+## Baselines that pass
+
+- `cargo +nightly-2025-07-14 test -p starknet_os_flow_tests --features starknet_transaction_prover/stwo_proving --release generate_proof_fixtures -- --ignored`
+  (fund-account tx, no syscalls)
+- `prove_and_verify_keccak_tx` modified to call `test_storage_read` instead of
+  `test_keccak` (non-keccak syscall)
+
+Both succeed on this branch, confirming the proving path itself works and only
+the keccak BUILTIN trip path is affected.

REPRO_KECCAK_PRIVACY_PROVE.md

@@ -34,6 +34,7 @@ starknet_committer = { workspace = true, features = ["testing"] }
 starknet_os = { workspace = true, features = ["include_program_output", "testing"] }
 starknet_patricia = { workspace = true, features = ["testing"] }
 starknet_patricia_storage = { workspace = true, features = ["testing"] }
+starknet_proof_verifier.workspace = true
 starknet_transaction_prover.workspace = true
 strum.workspace = true
 tokio.workspace = true

crates/starknet_os_flow_tests/Cargo.toml

@@ -273,6 +273,59 @@ async fn test_reverted_tx_os_error() {
         .run_virtual_expect_error("Reverted transactions are not supported in virtual OS mode");
 }
 
+/// Reproduces a privacy-prove failure when proving a virtual OS run that uses the keccak builtin.
+///
+/// Scenario:
+/// - Invoke `test_contract::test_keccak`, which uses both `keccak::keccak_u256s_le_inputs`
+///   (keccak BUILTIN) and `syscalls::keccak_syscall` with invalid input length (keccak SYSCALL
+///   failure path).
+/// - Run through the virtual OS (succeeds), then prove via `privacy-prove` and verify.
+///
+/// Observed result: OS execution succeeds; proving panics in
+/// `cairo-program-runner-lib::hints::load_cairo_pie::extract_segment` with
+/// `MemoryError::AddressNotRelocatable`, surfaced as
+///   "Hint Error: Error while relocating Cairo PIE memory: Memory addresses must be relocatable"
+/// at `simple_bootloader/execute_task.cairo:209`.
+///
+/// Likely cause: `privacy_prove::consts::CAIRO_RUN_CONFIG` selects `LayoutName::stwo_no_ecop`,
+/// which has `keccak: None` (`cairo-vm-3.2.0/src/types/instance_definitions/builtins_instance_def.rs`).
+/// The bootloader simulates keccak via `simple_bootloader_simulate_keccak`, but the simulation
+/// does not appear to cover relocating an inner task PIE whose keccak builtin segment is
+/// non-empty.
+///
+/// Isolation experiment: commenting out the `keccak::keccak_u256s_le_inputs` call in
+/// `test_contract::test_keccak` (leaving only the keccak SYSCALL failure path) makes this test
+/// pass — confirming the failure is triggered by keccak BUILTIN usage by the inner contract,
+/// not by the keccak SYSCALL itself.
+///
+/// To run manually: `cargo +nightly-2025-07-14 test -p starknet_os_flow_tests --features
+/// starknet_transaction_prover/stwo_proving --release prove_and_verify_keccak_tx -- --ignored
+/// --nocapture`
+#[tokio::test(flavor = "multi_thread")]
+#[ignore]
+async fn prove_and_verify_keccak_tx() {
+    let test_contract = FeatureContract::TestContract(CairoVersion::Cairo1(RunnableCairo1::Casm));
+
+    let (mut test_builder, [contract_address]) =
+        TestBuilder::create_standard_virtual([(test_contract, calldata![Felt::ONE, Felt::TWO])])
+            .await;
+
+    let calldata = create_calldata(contract_address, "test_keccak", &[]);
+    test_builder.add_funded_account_invoke(invoke_tx_args! { calldata });
+
+    let test_runner = test_builder.build().await;
+    let output = test_runner.run_virtual().prove().await;
+
+    let proof_facts = output.proof_facts.clone();
+    let proof = output.proof.clone();
+    tokio::task::spawn_blocking(move || {
+        starknet_proof_verifier::verify_proof(proof_facts, proof)
+    })
+    .await
+    .expect("proof verification task panicked")
+    .expect("proof verification should succeed");
+}
+
 /// Generates proof fixtures for the proof-flow integration test.
 /// To run manually: `cargo +nightly-2025-07-14 test -p starknet_os_flow_tests --features
 /// starknet_transaction_prover/stwo_proving --release generate_proof_fixtures -- --ignored`