Add scarb verify

.github/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
       - uses: Swatinem/rust-cache@v2
       - uses: taiki-e/install-action@nextest
       - name: nextest archive
-        run: cargo nextest archive --workspace --all-features --cargo-profile ci --archive-file 'nextest-archive-${{ matrix.platform.os }}.tar.zst' --exclude scarb-prove
+        run: cargo nextest archive --workspace --all-features --cargo-profile ci --archive-file 'nextest-archive-${{ matrix.platform.os }}.tar.zst' --exclude scarb-prove --exclude scarb-verify
       - uses: actions/upload-artifact@v4
         with:
           name: nextest-archive-${{ matrix.platform.os }}
@@ -82,8 +82,8 @@ jobs:
       - name: run tests
         run: cargo test -p scarb-metadata
 
-  test-scarb-prove:
-    name: test scarb-prove ${{ matrix.platform.name }}
+  test-nightly-crates:
+    name: test nightly crates ${{ matrix.platform.name }}
     runs-on: ${{ matrix.platform.os }}
     env:
       # TODO(#1915): Use stable toolchain once stwo is stable.
@@ -104,9 +104,11 @@ jobs:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
       - uses: Swatinem/rust-cache@v2
       - name: Build
-        run: cargo +stable build --workspace --all-features --exclude scarb-prove
+        run: cargo +stable build --workspace --all-features --exclude scarb-prove --exclude scarb-verify
       - name: Run scarb-prove tests
         run: cargo +${{ env.RUST_TOOLCHAIN }} test -p scarb-prove
+      - name: Run scarb-verify tests
+        run: cargo +${{ env.RUST_TOOLCHAIN }} test -p scarb-verify
 
   test-prebuilt-plugins:
     name: test prebuilt plugins ${{ matrix.platform.name }}
@@ -140,17 +142,17 @@ jobs:
       - uses: Swatinem/rust-cache@v2
       - run: cargo fmt --check
       # TODO(#1915): Build all crates with stable toolchain once stwo is stable.
-      - run: cargo clippy --all-targets --all-features --workspace --exclude scarb-prove -- --no-deps
+      - run: cargo clippy --all-targets --all-features --workspace --exclude scarb-prove --exclude scarb-verify -- --no-deps
         env:
           # Make sure CI fails on all warnings, including Clippy lints.
           RUSTFLAGS: "-Dwarnings"
-      - run: cargo doc --all-features --no-deps --workspace --exclude scarb-prove
+      - run: cargo doc --all-features --no-deps --workspace --exclude scarb-prove --exclude scarb-verify
         env:
           # Make sure CI fails on all warnings, including Clippy lints.
           RUSTDOCFLAGS: "-Dwarnings"
 
-  check-rust-scarb-prove:
-    name: check-rust (scarb-prove)
+  check-rust-nightly:
+    name: check-rust (nightly)
     runs-on: ubuntu-latest
     env:
       # TODO(#1915): Use stable toolchain once stwo is stable.
@@ -162,14 +164,14 @@ jobs:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
           components: rustfmt, clippy
       - uses: Swatinem/rust-cache@v2
-      - run: cargo +${{ env.RUST_TOOLCHAIN }} clippy --all-targets --all-features -p scarb-prove -- --no-deps
+      - run: cargo +${{ env.RUST_TOOLCHAIN }} clippy --all-targets --all-features -p scarb-prove -p scarb-verify -- --no-deps
         env:
           # Make sure CI fails on all warnings, including Clippy lints.
           RUSTFLAGS: "-Dwarnings"
-      - run: cargo +${{ env.RUST_TOOLCHAIN }} doc --all-features --no-deps -p scarb-prove
+      - run: cargo +${{ env.RUST_TOOLCHAIN }} doc --all-features --no-deps -p scarb-prove -p scarb-verify
         env:
           # Make sure CI fails on all warnings, including Clippy lints.
-          RUSTDOCFLAGS: "-Dwarnings"      
+          RUSTDOCFLAGS: "-Dwarnings"
 
   check-website:
     runs-on: ubuntu-latest

Cargo.toml

@@ -5,6 +5,7 @@ members = [
     "extensions/scarb-doc",
     "extensions/scarb-execute",
     "extensions/scarb-prove",
+    "extensions/scarb-verify",
     "extensions/scarb-cairo-language-server",
     "extensions/scarb-cairo-run",
     "extensions/scarb-cairo-test",
@@ -76,6 +77,8 @@ cairo-lang-utils = { version = "*", features = ["env_logger"] }
 cairo-language-server = "*"
 cairo-lint-core = "*"
 cairo-vm = "1.0.1"
+stwo_cairo_prover = { git = "https://github.com/starkware-libs/stwo-cairo", rev = "a27287c21e8b7e677b07cc40988c8c145533c55d" }
+stwo-prover = { git = "https://github.com/starkware-libs/stwo", rev = "af5475cb", features = ["parallel"] }
 camino = { version = "1", features = ["serde1"] }
 cargo_metadata = ">=0.18"
 clap = { version = "4", features = ["derive", "env", "string"] }

extensions/scarb-prove/Cargo.toml

@@ -20,15 +20,12 @@ serde.workspace = true
 camino.workspace = true
 serde_json.workspace = true
 create-output-dir = { path = "../../utils/create-output-dir" }
-stwo_cairo_prover = { git = "https://github.com/starkware-libs/stwo-cairo", rev = "a27287c21e8b7e677b07cc40988c8c145533c55d" }
-stwo-prover = { git = "https://github.com/starkware-libs/stwo", rev = "af5475cb", features = [
-    "parallel",
-] }
+stwo_cairo_prover.workspace = true
+stwo-prover.workspace = true
 scarb-execute = { path = "../scarb-execute" }
 
 [dev-dependencies]
 assert_fs.workspace = true
 scarb-test-support = { path = "../../utils/scarb-test-support" }
 snapbox.workspace = true
 predicates.workspace = true
-

extensions/scarb-verify/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "scarb-verify"
+publish = false
+
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+readme.workspace = true
+repository.workspace = true
+version.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+indoc.workspace = true
+scarb-metadata = { path = "../../scarb-metadata" }
+scarb-ui = { path = "../../utils/scarb-ui" }
+clap.workspace = true
+serde.workspace = true
+camino.workspace = true
+serde_json.workspace = true
+stwo_cairo_prover.workspace = true
+stwo-prover.workspace = true
+
+[dev-dependencies]
+assert_fs.workspace = true
+scarb-test-support = { path = "../../utils/scarb-test-support" }
+snapbox.workspace = true

extensions/scarb-verify/src/main.rs

@@ -0,0 +1,119 @@
+use anyhow::{ensure, Context, Result};
+use camino::{Utf8Path, Utf8PathBuf};
+use clap::Parser;
+use indoc::formatdoc;
+use scarb_metadata::{MetadataCommand, PackageMetadata};
+use scarb_ui::args::{PackagesFilter, VerbositySpec};
+use scarb_ui::components::Status;
+use scarb_ui::{OutputFormat, Ui};
+use std::env;
+use std::fs;
+use std::process::ExitCode;
+use stwo_cairo_prover::cairo_air::air::CairoProof;
+use stwo_cairo_prover::cairo_air::verify_cairo;
+use stwo_prover::core::vcs::blake2_merkle::{Blake2sMerkleChannel, Blake2sMerkleHasher};
+
+/// Verifies `scarb prove` output using Stwo verifier.
+#[derive(Parser, Clone, Debug)]
+#[clap(version, verbatim_doc_comment)]
+struct Args {
+    /// Name of the package.
+    #[command(flatten)]
+    packages_filter: PackagesFilter,
+
+    /// ID of `scarb execute` output for given package, for which proof was generated using `scarb prove`.
+    #[arg(long)]
+    execution_id: Option<u32>,
+
+    /// Proof file path.
+    #[arg(
+        long,
+        required_unless_present = "execution_id",
+        conflicts_with = "execution_id"
+    )]
+    proof_file: Option<Utf8PathBuf>,
+
+    /// Logging verbosity.
+    #[command(flatten)]
+    pub verbose: VerbositySpec,
+}
+
+fn main() -> ExitCode {
+    let args = Args::parse();
+    let ui = Ui::new(args.verbose.clone().into(), OutputFormat::Text);
+
+    match main_inner(args, ui.clone()) {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(error) => {
+            ui.error(format!("{error:#}"));
+            ExitCode::FAILURE
+        }
+    }
+}
+
+fn main_inner(args: Args, ui: Ui) -> Result<()> {
+    let scarb_target_dir = Utf8PathBuf::from(env::var("SCARB_TARGET_DIR")?);
+
+    let metadata = MetadataCommand::new().inherit_stderr().exec()?;
+    let package = args.packages_filter.match_one(&metadata)?;
+
+    let proof_path = if let Some(execution_id) = args.execution_id {
+        ui.print(Status::new("Verifying", &package.name));
+        resolve_proof_path_from_package(&scarb_target_dir, &package, execution_id)?
+    } else {
+        ui.print(Status::new("Verifying", "proof"));
+        args.proof_file.unwrap()
+    };
+
+    let proof = load_proof(&proof_path)?;
+
+    verify_cairo::<Blake2sMerkleChannel>(proof).with_context(|| "failed to verify proof")?;
+
+    ui.print(Status::new("Verified", "proof successfully"));
+
+    Ok(())
+}
+
+fn load_proof(path: &Utf8Path) -> Result<CairoProof<Blake2sMerkleHasher>> {
+    ensure!(
+        path.exists(),
+        format!("proof file does not exist at path: {path}")
+    );
+
+    let proof_contents =
+        fs::read_to_string(path).with_context(|| format!("failed to read proof file: {path}"))?;
+    let proof = serde_json::from_str(&proof_contents)
+        .with_context(|| format!("failed to deserialize proof file: {path}"))?;
+    Ok(proof)
+}
+
+fn resolve_proof_path_from_package(
+    scarb_target_dir: &Utf8Path,
+    package: &PackageMetadata,
+    execution_id: u32,
+) -> Result<Utf8PathBuf> {
+    let execution_dir = scarb_target_dir
+        .join("execute")
+        .join(&package.name)
+        .join(format!("execution{execution_id}"));
+
+    ensure!(
+        execution_dir.exists(),
+        formatdoc! {r#"
+            execution directory does not exist at path: {execution_dir}
+            help: make sure to run `scarb prove --execute` first
+            and that the execution ID is correct
+        "#}
+    );
+
+    let proof_path = execution_dir.join("proof").join("proof.json");
+    ensure!(
+        proof_path.exists(),
+        formatdoc! {r#"
+            proof file does not exist at path: {proof_path}
+            help: run `scarb prove --execution-id={execution_id}` first
+        "#}
+    );
+
+    Ok(proof_path)
+}

extensions/scarb-verify/tests/build.rs

@@ -0,0 +1,137 @@
+use assert_fs::TempDir;
+use indoc::indoc;
+use scarb_test_support::command::Scarb;
+use scarb_test_support::project_builder::ProjectBuilder;
+use snapbox::cmd::OutputAssert;
+
+fn build_executable_project() -> TempDir {
+    let t = TempDir::new().unwrap();
+    ProjectBuilder::start()
+        .name("hello")
+        .version("0.1.0")
+        .dep_cairo_execute()
+        .manifest_extra(indoc! {r#"
+                [executable]
+
+                [cairo]
+                enable-gas = false
+            "#})
+        .lib_cairo(indoc! {r#"
+            #[executable]
+            fn main() -> felt252 {
+                42
+            }
+        "#})
+        .build(&t);
+    t
+}
+
+// Disabled due to `scarb prove` not being supported on Windows
+#[cfg(not(windows))]
+#[test]
+fn verify_from_execution_output() {
+    let t = build_executable_project();
+
+    Scarb::quick_snapbox()
+        .arg("execute")
+        .current_dir(&t)
+        .assert()
+        .success();
+
+    Scarb::quick_snapbox()
+        .arg("prove")
+        .arg("--execution-id=1")
+        .current_dir(&t)
+        .assert()
+        .success();
+
+    Scarb::quick_snapbox()
+        .arg("verify")
+        .arg("--execution-id=1")
+        .current_dir(&t)
+        .assert()
+        .success()
+        .stdout_matches(indoc! {r#"
+        [..]Verifying hello
+        [..]Verified proof successfully
+        "#});
+}
+
+// Disabled due to `scarb prove` not being supported on Windows
+#[cfg(not(windows))]
+#[test]
+fn verify_from_path() {
+    let t = build_executable_project();
+
+    Scarb::quick_snapbox()
+        .arg("execute")
+        .current_dir(&t)
+        .assert()
+        .success();
+
+    Scarb::quick_snapbox()
+        .arg("prove")
+        .arg("--execution-id=1")
+        .current_dir(&t)
+        .assert()
+        .success();
+
+    Scarb::quick_snapbox()
+        .arg("verify")
+        .arg("--proof-file=target/execute/hello/execution1/proof/proof.json")
+        .current_dir(&t)
+        .assert()
+        .success()
+        .stdout_matches(indoc! {r#"
+        [..]Verifying proof
+        [..]Verified proof successfully
+        "#});
+}
+
+#[test]
+fn verify_fails_when_execution_output_not_found() {
+    let t = build_executable_project();
+
+    output_assert(
+        Scarb::quick_snapbox()
+            .arg("verify")
+            .arg("--execution-id=1")
+            .current_dir(&t)
+            .assert()
+            .failure(),
+        indoc! {r#"
+        [..]Verifying hello
+        error: execution directory does not exist at path: [..]/target/execute/hello/execution1
+        help: make sure to run `scarb prove --execute` first
+        and that the execution ID is correct
+
+        "#},
+    )
+}
+
+#[test]
+fn verify_fails_when_proof_file_not_found() {
+    let t = build_executable_project();
+
+    output_assert(
+        Scarb::quick_snapbox()
+            .arg("verify")
+            .arg("--proof-file=nonexistent.json")
+            .current_dir(&t)
+            .assert()
+            .failure(),
+        indoc! {r#"
+        [..]Verifying proof
+        error: proof file does not exist at path: nonexistent.json
+        "#},
+    )
+}
+
+fn output_assert(output: OutputAssert, expected: &str) {
+    #[cfg(windows)]
+    output.stdout_matches(format!(
+        "{expected}error: process did not exit successfully: exit code: 1\n"
+    ));
+    #[cfg(not(windows))]
+    output.stdout_matches(expected);
+}