Drop _elf suffix from API (risc0#1195)

This is a breaking change which causes the older doc-tests to fail. A
refactor is made so that each doc-test version has its own workspace for
deps.

.github/workflows/website-test.yml

@@ -20,23 +20,79 @@ env:
   RISC0_TOOLCHAIN_VERSION: test-release-2
 
 jobs:
+  changes:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
+    outputs:
+      versions: ${{ steps.filter.outputs.changes }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: risc0/paths-filter@4067d885736b84de7c414f582ac45897079b0a78
+        id: filter
+        with:
+          filters: |
+            main:
+              - bonsai/**
+              - risc0/**
+              - website/api/**
+              - website/doc-test/main/**
+              - website/docs/**
+            version-0.18:
+              - website/api_versioned_docs/version-0.18/**
+              - website/doc-test/version-0.18/**
+            version-0.19:
+              - website/api_versioned_docs/version-0.19/**
+              - website/doc-test/version-0.19/**
+
+  # see: https://github.com/orgs/community/discussions/26822
   doc-test:
-    runs-on: [self-hosted, prod, Linux, cpu]
+    if: always()
+    needs:
+      - matrix
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check all job status
+        # see https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#needs-context
+        # see https://stackoverflow.com/a/67532120/4907315
+        if: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') }}
+        run: exit 1
+
+  matrix:
+    needs: changes
+    strategy:
+      fail-fast: false
+      matrix:
+        version: ${{ fromJSON(needs.changes.outputs.versions) }}
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
         with:
           # Recursive checkout required to build Solidity contracts and bindings.
           submodules: recursive
       - uses: ./.github/actions/rustup
+        with:
+          toolchain: "1.73"
       - uses: ./.github/actions/sccache
         with:
           key: Linux-default
       - uses: risc0/foundry-toolchain@2fe7e70b520f62368a0e3c464f997df07ede420f
         with:
           version: nightly-34f684ddfacc5b2ed371353ba6f730c485616ffe
-      - run: cargo run --bin cargo-risczero --no-default-features -- risczero install --version $RISC0_TOOLCHAIN_VERSION
-      - name: build
-        run: cargo test -p doc-test --no-run
-      - name: test
-        run: cargo test -p doc-test
+      - uses: risc0/cargo-install@2cfb0024938d23011106cbf127b393bc83fddba1
+        with:
+          crate: cargo-binstall
+          version: "1.4"
+      - run: cargo binstall -y --force [email protected]
+      - run: cargo risczero install --version $RISC0_TOOLCHAIN_VERSION
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: build ${{ matrix.version }}
+        run: cargo test --release --no-run
+        working-directory: website/doc-test/${{ matrix.version }}
+      - name: test ${{ matrix.version }}
+        run: cargo test --release
+        working-directory: website/doc-test/${{ matrix.version }}
+
       - run: sccache --show-stats

Cargo.toml

@@ -19,7 +19,7 @@ members = [
   "risc0/zkvm/methods",
   "risc0/zkvm/platform",
   "risc0/zkvm/receipts",
-  "website/doc-test",
+  "website/doc-test/main",
   "xtask",
 ]
 exclude = ["tools/crates-validator"]

bonsai/examples/governance/methods/src/lib.rs

@@ -44,7 +44,7 @@ mod test {
             .build()
             .unwrap();
         let exec = default_executor();
-        let session = exec.execute_elf(env, FINALIZE_VOTES_ELF).unwrap();
+        let session = exec.execute(env, FINALIZE_VOTES_ELF).unwrap();
         assert_eq!(&session.journal.bytes, TEST_OUTPUT);
     }
 }

bonsai/examples/governance/relay/src/lib.rs

@@ -35,7 +35,7 @@ pub fn execute_locally(elf: &[u8], input: Vec<u8>) -> Result<Output> {
         .build()
         .context("Failed to build ExecutorEnv")?;
     let exec = default_executor();
-    let session = exec.execute_elf(env, elf).context("Execution failed")?;
+    let session = exec.execute(env, elf).context("Execution failed")?;
     Ok(Output::Execution {
         journal: session.journal.bytes.into(),
     })

bonsai/rest-api-mock/src/prover.rs

@@ -94,7 +94,7 @@ impl Prover {
                     })?;
                 let exec = default_executor();
                 let session = exec
-                    .execute_elf(env, elf)
+                    .execute(env, elf)
                     .context("Executor failed to generate a successful session")?;
 
                 let receipt = Receipt {

examples/bevy/src/main.rs

@@ -30,7 +30,7 @@ fn main() {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(env, BEVY_GUEST_ELF).unwrap();
+    let receipt = prover.prove(env, BEVY_GUEST_ELF).unwrap();
 
     // The prover already runs a verify internally and so it's redundant to verify
     // again here. However, this is how other users would verify the receipt:

examples/chess/src/main.rs

@@ -62,7 +62,7 @@ fn chess(inputs: &Inputs) -> Receipt {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    prover.prove_elf(env, CHECKMATE_ELF).unwrap()
+    prover.prove(env, CHECKMATE_ELF).unwrap()
 }
 
 #[cfg(test)]

examples/cycle-counter/src/lib.rs

@@ -48,7 +48,7 @@ pub trait CycleCounter {
 
 pub fn exec<'a>(name: &str, elf: &[u8], env: ExecutorEnv<'a>) -> Metrics {
     let exec = default_executor();
-    let session_info = exec.execute_elf(env, elf).unwrap();
+    let session_info = exec.execute(env, elf).unwrap();
     let cycles = session_info
         .segments
         .iter()

examples/digital-signature/src/lib.rs

@@ -57,7 +57,7 @@ pub fn sign(pass_str: impl AsRef<[u8]>, msg_str: impl AsRef<[u8]>) -> Result<Sig
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(env, SIGN_ELF)?;
+    let receipt = prover.prove(env, SIGN_ELF)?;
 
     Ok(SignatureWithReceipt { receipt })
 }

examples/ecdsa/src/bin/benchmark.rs

@@ -19,5 +19,5 @@ use risc0_zkvm::{default_executor, ExecutorEnv};
 fn main() {
     let env = ExecutorEnv::builder().build().unwrap();
     let exec = default_executor();
-    std::hint::black_box(exec.execute_elf(env, BENCHMARK_ELF)).unwrap();
+    std::hint::black_box(exec.execute(env, BENCHMARK_ELF)).unwrap();
 }

examples/ecdsa/src/main.rs

@@ -40,7 +40,7 @@ fn prove_ecdsa_verification(
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    prover.prove_elf(env, ECDSA_VERIFY_ELF).unwrap()
+    prover.prove(env, ECDSA_VERIFY_ELF).unwrap()
 }
 
 fn main() {

examples/hello-world/src/lib.rs

@@ -36,7 +36,7 @@ pub fn multiply(a: u64, b: u64) -> (Receipt, u64) {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(env, MULTIPLY_ELF).unwrap();
+    let receipt = prover.prove(env, MULTIPLY_ELF).unwrap();
 
     // Extract journal of receipt (i.e. output c, where c = a * b)
     let c: u64 = receipt.journal.decode().expect(

examples/json/src/main.rs

@@ -38,7 +38,7 @@ fn search_json(data: &str) -> Outputs {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(env, SEARCH_JSON_ELF).unwrap();
+    let receipt = prover.prove(env, SEARCH_JSON_ELF).unwrap();
 
     receipt.journal.decode().unwrap()
 }

examples/password-checker/src/main.rs

@@ -42,7 +42,7 @@ fn password_checker(request: PasswordRequest) -> Digest {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(env, PW_CHECKER_ELF).unwrap();
+    let receipt = prover.prove(env, PW_CHECKER_ELF).unwrap();
 
     receipt.journal.decode().unwrap()
 }

examples/profiling/src/main.rs

@@ -26,7 +26,7 @@ fn main() -> anyhow::Result<()> {
     // Execute the guest code.
     let env = ExecutorEnv::builder().write(&iterations)?.build()?;
     let exec = default_executor();
-    exec.execute_elf(env, FIBONACCI_ELF)?;
+    exec.execute(env, FIBONACCI_ELF)?;
 
     Ok(())
 }

examples/prorata/src/main.rs

@@ -93,7 +93,7 @@ fn allocate(input: &str, output: &str, recipient: &str, amount: &Decimal) {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(env, PRORATA_GUEST_ELF).unwrap();
+    let receipt = prover.prove(env, PRORATA_GUEST_ELF).unwrap();
 
     // Verify receipt to confirm that it is correctly formed. Not strictly
     // necessary.

examples/sha/src/main.rs

@@ -43,7 +43,7 @@ fn provably_hash(input: &str, use_rust_crypto: bool) -> (Digest, Receipt) {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(env, elf).unwrap();
+    let receipt = prover.prove(env, elf).unwrap();
 
     let digest = receipt.journal.decode().unwrap();
     (digest, receipt)

examples/smartcore-ml/src/main.rs

@@ -71,7 +71,7 @@ fn predict() -> Vec<u32> {
 
     // This initiates a session, runs the STARK prover on the resulting exection
     // trace, and produces a receipt.
-    let receipt = prover.prove_elf(env, ML_TEMPLATE_ELF).unwrap();
+    let receipt = prover.prove(env, ML_TEMPLATE_ELF).unwrap();
 
     // We read the result that the guest code committed to the journal. The
     // receipt can also be serialized and sent to a verifier.
@@ -159,7 +159,7 @@ mod test {
 
         // We run the executor and bypass the prover.
         let exec = default_executor();
-        let session = exec.execute_elf(env, ML_TEMPLATE_ELF).unwrap();
+        let session = exec.execute(env, ML_TEMPLATE_ELF).unwrap();
 
         // We read the result commited to the journal by the guest code.
         let result: Vec<f64> = session.journal.decode().unwrap();

examples/voting-machine/src/lib.rs

@@ -78,7 +78,7 @@ impl PollingStation {
         tracing::info!("init");
         let env = ExecutorEnv::builder().write(&self.state)?.build()?;
         let prover = default_prover();
-        let receipt = prover.prove_elf(env, INIT_ELF)?;
+        let receipt = prover.prove(env, INIT_ELF)?;
         Ok(InitMessage { receipt })
     }
 
@@ -91,7 +91,7 @@ impl PollingStation {
             .stdout(&mut output)
             .build()?;
         let prover = default_prover();
-        let receipt = prover.prove_elf(env, SUBMIT_ELF)?;
+        let receipt = prover.prove(env, SUBMIT_ELF)?;
         self.state = from_slice(&output)?;
         Ok(SubmitBallotMessage { receipt })
     }
@@ -105,7 +105,7 @@ impl PollingStation {
             .stdout(&mut output)
             .build()?;
         let prover = default_prover();
-        let receipt = prover.prove_elf(env, FREEZE_ELF)?;
+        let receipt = prover.prove(env, FREEZE_ELF)?;
         let result: FreezeVotingMachineResult = from_slice(&output)?;
         self.state = result.state;
         Ok(FreezeStationMessage { receipt })

examples/waldo/src/bin/prove.rs

@@ -132,7 +132,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(env, IMAGE_CROP_ELF).unwrap();
+    let receipt = prover.prove(env, IMAGE_CROP_ELF).unwrap();
 
     // Save the receipt to disk so it can be sent to the verifier.
     fs::write(&args.receipt, bincode::serialize(&receipt).unwrap())?;

examples/wasm/src/main.rs

@@ -89,7 +89,7 @@ fn run_guest(iters: i32) -> i32 {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(env, WASM_INTERP_ELF).unwrap();
+    let receipt = prover.prove(env, WASM_INTERP_ELF).unwrap();
 
     receipt.verify(WASM_INTERP_ID).expect(
         "Code you have proven should successfully verify; did you specify the correct image ID?",

examples/wordle/src/main.rs

@@ -51,7 +51,7 @@ impl<'a> Server<'a> {
         let prover = default_prover();
 
         // Produce a receipt by proving the specified ELF binary.
-        prover.prove_elf(env, WORDLE_GUEST_ELF).unwrap()
+        prover.prove(env, WORDLE_GUEST_ELF).unwrap()
     }
 }
 

examples/xgboost/src/main.rs

@@ -55,7 +55,7 @@ fn predict() -> f64 {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(env, XGBOOST_ELF).unwrap();
+    let receipt = prover.prove(env, XGBOOST_ELF).unwrap();
 
     // We return the inference value committed to the journal.
     receipt.journal.decode().unwrap()

examples/zkevm-demo/src/main.rs

@@ -94,7 +94,7 @@ async fn main() {
     let prover = default_prover();
 
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove_elf(exec_env, EVM_ELF).unwrap();
+    let receipt = prover.prove(exec_env, EVM_ELF).unwrap();
 
     let res: EvmResult = receipt
         .journal

risc0/cargo-risczero/src/commands/build.rs

@@ -206,7 +206,7 @@ impl BuildCommand {
                     .build()?;
 
                 let exec = default_executor();
-                let session = exec.execute_elf(env, &fs::read(test)?)?;
+                let session = exec.execute(env, &fs::read(test)?)?;
                 ensure!(
                     session.exit_code == ExitCode::Halted(0),
                     "test exited with code {:?}",

risc0/r0vm/tests/external_prover.rs

@@ -25,7 +25,7 @@ fn prove_nothing() -> Result<Receipt> {
         .unwrap();
     let r0vm_path = cargo_bin("r0vm");
     let prover = ExternalProver::new("r0vm", r0vm_path);
-    prover.prove_elf(env, MULTI_TEST_ELF)
+    prover.prove(env, MULTI_TEST_ELF)
 }
 
 #[test_log::test]

risc0/zkvm/src/host/api/server.rs

@@ -351,7 +351,7 @@ impl Server {
             let opts: ProverOpts = request.opts.ok_or(malformed_err())?.into();
             let prover = get_prover_server(&opts)?;
             let ctx = VerifierContext::default();
-            let receipt = prover.prove_elf_with_ctx(env, &ctx, &bytes)?;
+            let receipt = prover.prove_with_ctx(env, &ctx, &bytes)?;
 
             let receipt_pb: pb::core::Receipt = receipt.into();
             let receipt_bytes = receipt_pb.encode_to_vec();

risc0/zkvm/src/host/api/tests.rs

@@ -135,7 +135,7 @@ fn with_server<T, F: FnOnce() -> Result<T>>(addr: SocketAddr, f: F) -> T {
 }
 
 #[test]
-fn execute_elf() {
+fn execute() {
     let env = ExecutorEnv::builder()
         .write(&MultiTestSpec::DoNothing)
         .unwrap()
@@ -146,7 +146,7 @@ fn execute_elf() {
 }
 
 #[test]
-fn prove_elf() {
+fn prove() {
     let env = ExecutorEnv::builder()
         .write(&MultiTestSpec::DoNothing)
         .unwrap()

risc0/zkvm/src/host/client/prove/bonsai.rs

@@ -42,7 +42,7 @@ impl Prover for BonsaiProver {
         self.name.clone()
     }
 
-    fn prove_elf_with_ctx(
+    fn prove_with_ctx(
         &self,
         env: ExecutorEnv<'_>,
         ctx: &VerifierContext,

risc0/zkvm/src/host/client/prove/external.rs

@@ -40,7 +40,7 @@ impl ExternalProver {
 }
 
 impl Prover for ExternalProver {
-    fn prove_elf_with_ctx(
+    fn prove_with_ctx(
         &self,
         env: ExecutorEnv<'_>,
         ctx: &VerifierContext,
@@ -74,7 +74,7 @@ impl Prover for ExternalProver {
 }
 
 impl Executor for ExternalProver {
-    fn execute_elf(&self, env: ExecutorEnv<'_>, elf: &[u8]) -> Result<SessionInfo> {
+    fn execute(&self, env: ExecutorEnv<'_>, elf: &[u8]) -> Result<SessionInfo> {
         let binary = Asset::Inline(elf.to_vec().into());
         let client = ApiClient::new_sub_process(&self.r0vm_path)?;
         let segments_out = AssetRequest::Inline;