feat: update zisk to v1.3.0-alpha and use blake3 hash family

Cargo.toml

@@ -160,19 +160,19 @@ sp1-zkvm = { git = "https://github.com/succinctlabs/sp1", tag = "v6.6.0", defaul
 sp1-libzkevm = { git = "https://github.com/succinctlabs/sp1", tag = "v6.6.0", package = "libzkevm" }
 
 # ZisK dependencies
-proofman-fields = "1.2.0-alpha"
-proofman-starks-lib-c = "1.2.0-alpha"
-proofman-util = "1.2.0-alpha"
-proofman-verifier = "1.2.0-alpha"
-zisk-common = "1.2.0-alpha"
-zisk-core = "1.2.0-alpha"
-zisk-prover-backend = "1.2.0-alpha"
-zisk-rom-setup = "1.2.0-alpha"
-zisk-sm-rom = "1.2.0-alpha"
-zisk-transpiler-riscv = "1.2.0-alpha"
-zisk-verifier = "1.2.0-alpha"
-ziskemu = "1.2.0-alpha"
-ziskos = { version = "1.2.0-alpha", default-features = false }
+proofman-fields = "1.3.0-alpha"
+proofman-starks-lib-c = "1.3.0-alpha"
+proofman-util = "1.3.0-alpha"
+proofman-verifier = "1.3.0-alpha"
+zisk-common = "1.3.0-alpha"
+zisk-core = "1.3.0-alpha"
+zisk-prover-backend = "1.3.0-alpha"
+zisk-rom-setup = "1.3.0-alpha"
+zisk-sm-rom = "1.3.0-alpha"
+zisk-transpiler-riscv = "1.3.0-alpha"
+zisk-verifier = "1.3.0-alpha"
+ziskemu = "1.3.0-alpha"
+ziskos = { version = "1.3.0-alpha", default-features = false }
 
 # Local dependencies
 ere-compiler = { path = "crates/compiler/cli" }

README.md

@@ -160,7 +160,7 @@ Different zkVMs handles public values in different approaches:
 | ------ | --------------------------------------------------------------------------- | --------- | :---: | :-------: | :-----: |
 | OpenVM | [`2.1.0-preview`](https://github.com/openvm-org/openvm/tree/v2.1.0-preview) | `RV64IMA` |   V   |           |         |
 | SP1    | [`6.6.0`](https://github.com/succinctlabs/sp1/tree/v6.6.0)                  | `RV64IMA` |   V   |           |         |
-| ZisK   | [`1.2.0-alpha`](https://github.com/0xPolygonHermez/zisk/tree/v1.2.0-alpha)  | `RV64IMA` |   V   |     V     |    V    |
+| ZisK   | [`1.3.0-alpha`](https://github.com/0xPolygonHermez/zisk/tree/v1.3.0-alpha)  | `RV64IMA` |   V   |     V     |    V    |
 
 ## Examples
 

crates/cluster-client/zisk/proto/zisk_coordinator_api.proto

@@ -1,4 +1,4 @@
-// Copied from https://github.com/0xPolygonHermez/zisk/blob/v1.2.0-alpha/distributed/crates/coordinator-api/proto/zisk_coordinator_api.proto.
+// Copied from https://github.com/0xPolygonHermez/zisk/blob/v1.3.0-alpha/distributed/crates/coordinator-api/proto/zisk_coordinator_api.proto.
 
 syntax = "proto3";
 

crates/cluster-client/zisk/src/client.rs

@@ -1,12 +1,12 @@
 //! Remote ZisK cluster proving.
 
-use core::time::Duration;
+use core::{iter, time::Duration};
 
 use ere_compiler_core::Elf;
 use ere_prover_core::{Input, RemoteProverConfig, zkVMVerifier};
 use ere_verifier_zisk::{
-    PROGRAM_VK_WORDS, PUBLIC_VALUES_WORDS, VADCOP_FINAL_HASH_FAMILY, VadcopFinalProof,
-    ZiskProgramVk, ZiskProof, ZiskVerifier,
+    IS_VADCOP_FINAL_PROOF, PROGRAM_VK_WORDS, PUBLIC_VALUES_WORDS, VADCOP_FINAL_HASH_FAMILY,
+    VadcopFinalProof, ZiskProgramVk, ZiskProof, ZiskVerifier,
 };
 use serde::Deserialize;
 use tokio::time::{Instant, sleep, timeout, timeout_at};
@@ -278,7 +278,7 @@ fn prove_job(hash_id: &str, input: &Input) -> JobKind {
                     data: framed_stdin(input.stdin()),
                 })),
             }),
-            proof_dest: ProofKind::StarkMinimal as i32,
+            proof_dest: ProofKind::Stark as i32,
             proof_timeout: None,
             hints: None,
         })),
@@ -299,7 +299,7 @@ fn framed_stdin(data: &[u8]) -> Vec<u8> {
 
 fn parse_proof(bytes: &[u8]) -> Result<ZiskProof, Error> {
     /// Mirrors `zisk_common::VadcopKind`, whose discriminant order fixes the
-    /// encoding. Only `Minimal` is accepted below.
+    /// encoding. Only `Final` is accepted below.
     #[derive(Deserialize, PartialEq)]
     enum VadcopKind {
         Final,
@@ -315,8 +315,8 @@ fn parse_proof(bytes: &[u8]) -> Result<ZiskProof, Error> {
             kind: VadcopKind,
             hash: String,
             /// Canonical flag-free `[program_vk(4) | inputs(64)]` at full u64
-            /// width. A minimal proof carries no `is_vadcop_final_proof` flag,
-            /// so this is already the vector the verifier commits to.
+            /// width, for every kind. The `is_vadcop_final_proof` flag the
+            /// uncompressed stage commits at index 0 lives in `kind`.
             publics_full: Vec<u64>,
         },
         Plonk,
@@ -356,7 +356,7 @@ fn parse_proof(bytes: &[u8]) -> Result<ZiskProof, Error> {
     else {
         return Err(ere_verifier_zisk::Error::InvalidVadcopFinalProofKind)?;
     };
-    if kind != VadcopKind::Minimal || hash != VADCOP_FINAL_HASH_FAMILY {
+    if kind != VadcopKind::Final || hash != VADCOP_FINAL_HASH_FAMILY {
         Err(ere_verifier_zisk::Error::InvalidVadcopFinalProofKind)?;
     }
     if publics_full.len() != PROGRAM_VK_WORDS + PUBLIC_VALUES_WORDS {
@@ -366,10 +366,15 @@ fn parse_proof(bytes: &[u8]) -> Result<ZiskProof, Error> {
         })?;
     };
 
+    // Re-add the leaf flag the uncompressed stage commits at index 0.
+    let public_values = iter::once(IS_VADCOP_FINAL_PROOF)
+        .chain(publics_full)
+        .collect();
+
     Ok(ZiskProof(VadcopFinalProof::new(
         proof,
-        publics_full,
-        true,
+        public_values,
+        false,
         VADCOP_FINAL_HASH_FAMILY.to_string(),
     )))
 }

crates/compiler/zisk/src/rust_rv64ima.rs

@@ -35,7 +35,7 @@ const CARGO_BUILD_OPTIONS: &[&str] = &[
     "-Zjson-target-spec",
 ];
 
-/// Copied from https://github.com/0xPolygonHermez/zisk/blob/v1.2.0-alpha/ziskbuild/zisk_linker_script.ld.
+/// Copied from https://github.com/0xPolygonHermez/zisk/blob/v1.3.0-alpha/ziskbuild/zisk_linker_script.ld.
 ///
 /// The ZisK target carries no built-in link script, so both compilers pass this one explicitly,
 /// matching what `zisk-build` injects for its own guest builds.

crates/compiler/zisk/src/rust_rv64ima/link.x

@@ -1,4 +1,4 @@
-/* Copied from https://github.com/0xPolygonHermez/zisk/blob/v1.2.0-alpha/ziskbuild/zisk_linker_script.ld */
+/* Copied from https://github.com/0xPolygonHermez/zisk/blob/v1.3.0-alpha/ziskbuild/zisk_linker_script.ld */
 
 OUTPUT_FORMAT("elf64-littleriscv")
 OUTPUT_ARCH("riscv")

crates/prover/zisk/src/sdk/local.rs

@@ -10,7 +10,7 @@ use once_cell::sync::OnceCell;
 use parking_lot::Mutex;
 use proofman_fields::{Field, Goldilocks, PrimeField64};
 use proofman_util::DeviceBuffer;
-use zisk_common::{HashMode, ProofKind, ZiskPaths, io::ZiskStdin};
+use zisk_common::{HashMode, ZiskPaths, io::ZiskStdin};
 use zisk_prover_backend::{
     Asm, AsmOptions, BackendProverOpts, GuestProgram, ProverClientBuilder, ZiskProver,
 };
@@ -112,7 +112,6 @@ impl LocalProver {
         let started = Instant::now();
         let output = prover
             .prove(&self.program, stdin)
-            .wrap_proof(ProofKind::VadcopFinalMinimal)
             .run()
             .map_err(Error::Prove)?;
         let proving_time = started.elapsed();

crates/prover/zisk/src/sdk/proving_key.rs

@@ -10,12 +10,12 @@ use md5::{Digest, Md5};
 use parking_lot::Mutex;
 use zisk_common::ZiskPaths;
 
-/// URL of the proving key of v1.2.0-alpha.
+/// URL of the blake3 proving key of v1.3.0-alpha.
 const PROVING_KEY_URL: &str =
-    "https://storage.googleapis.com/zisk-setup/zisk-provingkey-1.2.0-alpha.tar.gz";
+    "https://storage.googleapis.com/zisk-setup/zisk-provingkey-1.3.0-alpha-blake3.tar.gz";
 
-/// MD5 of the proving key of v1.2.0-alpha.
-const PROVING_KEY_MD5: [u8; 16] = hex_literal::hex!("51e142e7217b807bec25af465b7eeb71");
+/// MD5 of the blake3 proving key of v1.3.0-alpha.
+const PROVING_KEY_MD5: [u8; 16] = hex_literal::hex!("879b7f726cf48e8a53be877020068548");
 
 /// Marker file holding the hex MD5 of the unpacked archive, written last.
 const PROVING_KEY_MD5_FILE: &str = ".md5";

crates/verifier/zisk/src/error.rs

@@ -16,19 +16,23 @@ pub enum Error {
     #[error("Non-canonical ProgramVk")]
     NonCanonicalProgramVk,
 
-    /// Expected compressed VadcopFinalProof
-    #[error("Invalid kind of VadcopFinalProof, expected compressed")]
+    /// Expected uncompressed VadcopFinalProof
+    #[error("Invalid kind of VadcopFinalProof, expected uncompressed")]
     InvalidVadcopFinalProofKind,
 
-    /// Public values of VadcopFinalProof was not the expected 68 words.
+    /// Public values of VadcopFinalProof was not the expected length.
     #[error("Invalid public value length of VadcopFinalProof, expected: {expected}, got: {got}")]
     InvalidPublicValueLength { expected: usize, got: usize },
 
+    /// Expected leaf VadcopFinalProof
+    #[error("Invalid is_vadcop_final_proof flag of VadcopFinalProof, got: {got}")]
+    UnexpectedVadcopFinalFlag { got: u64 },
+
     /// User public values was not u32.
     #[error("Invalid word in user public values, expected u32")]
     InvalidPublicValue,
 
-    /// `verify_vadcop_final_compressed_u64` returned false.
+    /// `verify_vadcop_final` returned false.
     #[error("Invalid proof")]
     InvalidProof,
 

crates/verifier/zisk/src/lib.rs

@@ -9,7 +9,8 @@ pub use crate::{
     error::Error,
     program_vk::ZiskProgramVk,
     proof::{
-        PROGRAM_VK_WORDS, PUBLIC_VALUES_BYTES, PUBLIC_VALUES_WORDS, VadcopFinalProof, ZiskProof,
+        IS_VADCOP_FINAL_PROOF, PROGRAM_VK_WORDS, PUBLIC_VALUES_BYTES, PUBLIC_VALUES_WORDS,
+        VadcopFinalProof, ZiskProof,
     },
     verifier::{VADCOP_FINAL_HASH_FAMILY, ZiskVerifier, ensure_program_vk_matches},
 };

crates/verifier/zisk/src/proof.rs

@@ -1,7 +1,8 @@
 use ere_verifier_core::PublicValues;
 pub use proofman_verifier::VadcopFinalProof;
 use serde::{Deserialize, Serialize};
-use zisk_verifier::{PROGRAM_VK_LEN, ZISK_PUBLICS};
+pub use zisk_verifier::IS_VADCOP_FINAL_PROOF;
+use zisk_verifier::{PROGRAM_VK_LEN, VADCOP_FINAL_FLAG_LEN, ZISK_PUBLICS};
 
 use crate::{Error, VADCOP_FINAL_HASH_FAMILY, ZiskProgramVk};
 
@@ -19,24 +20,33 @@ pub struct ZiskProof(pub VadcopFinalProof);
 
 impl ZiskProof {
     pub fn program_vk_and_public_values(&self) -> Result<(ZiskProgramVk, PublicValues), Error> {
-        if !self.0.compressed {
+        if self.0.compressed {
             return Err(Error::InvalidVadcopFinalProofKind);
         }
 
         if self.0.hash != VADCOP_FINAL_HASH_FAMILY {
             return Err(Error::InvalidVadcopFinalProofKind);
         }
 
-        if self.0.public_values.len() != PROGRAM_VK_LEN + ZISK_PUBLICS {
+        if self.0.public_values.len() != VADCOP_FINAL_FLAG_LEN + PROGRAM_VK_LEN + ZISK_PUBLICS {
             return Err(Error::InvalidPublicValueLength {
-                expected: PROGRAM_VK_LEN + ZISK_PUBLICS,
+                expected: VADCOP_FINAL_FLAG_LEN + PROGRAM_VK_LEN + ZISK_PUBLICS,
                 got: self.0.public_values.len(),
             });
         }
 
-        let program_vk = self.0.public_values[..PROGRAM_VK_LEN].try_into().unwrap();
+        if self.0.public_values[0] != IS_VADCOP_FINAL_PROOF {
+            return Err(Error::UnexpectedVadcopFinalFlag {
+                got: self.0.public_values[0],
+            });
+        }
+
+        let program_vk = self.0.public_values
+            [VADCOP_FINAL_FLAG_LEN..VADCOP_FINAL_FLAG_LEN + PROGRAM_VK_LEN]
+            .try_into()
+            .unwrap();
 
-        let public_values = self.0.public_values[PROGRAM_VK_LEN..]
+        let public_values = self.0.public_values[VADCOP_FINAL_FLAG_LEN + PROGRAM_VK_LEN..]
             .iter()
             .map(|v| u32::try_from(*v).ok().map(|value| value.to_le_bytes()))
             .collect::<Option<Vec<_>>>()

crates/verifier/zisk/src/verifier.rs

@@ -1,7 +1,7 @@
 use ere_verifier_core::{PublicValues, zkVMVerifier};
-use proofman_verifier::{Poseidon1Verifier, Verifier};
+use zisk_verifier::verify_vadcop_final;
 
-use crate::{Error, ZiskProgramVk, ZiskProof, verifier::vk::VADCOP_FINAL_COMPRESSED_VK};
+use crate::{Error, ZiskProgramVk, ZiskProof, verifier::vk::VADCOP_FINAL_VK};
 
 include!(concat!(env!("OUT_DIR"), "/name_and_sdk_version.rs"));
 
@@ -39,8 +39,7 @@ impl zkVMVerifier for ZiskVerifier {
 
         ensure_program_vk_matches(self.program_vk, program_vk)?;
 
-        if !Poseidon1Verifier.verify_vadcop_final_compressed(&proof.0, &VADCOP_FINAL_COMPRESSED_VK)
-        {
+        if !verify_vadcop_final(&proof.0, &VADCOP_FINAL_VK) {
             return Err(Error::InvalidProof);
         }
 

crates/verifier/zisk/src/verifier/vk.rs

@@ -1,42 +1,41 @@
-/// Aggregation verifying key for VadcopFinalMinimal proofs in zisk v1.2.0-alpha, under the default
-/// Poseidon1 hash family.
+/// Aggregation verifying key for VadcopFinal proofs in zisk v1.3.0-alpha, under the blake3 hash
+/// family.
 ///
 /// To reproduce:
 ///
 /// ```bash
-/// cat $HOME/.zisk/provingKey/zisk/vadcop_final_compressed/vadcop_final_compressed.verkey.json
+/// cat $HOME/.zisk/provingKey/zisk/vadcop_final/vadcop_final.verkey.json
 /// ```
-pub const VADCOP_FINAL_COMPRESSED_VK: [u64; 4] = [
-    15008563959707073304,
-    10715099813120081992,
-    18339358923736659668,
-    13838445471377553159,
+pub const VADCOP_FINAL_VK: [u64; 4] = [
+    5837235217183667153,
+    1180390204286480274,
+    11081033657594026385,
+    8649035900029615545,
 ];
 
-/// Hash family the [`VADCOP_FINAL_COMPRESSED_VK`] was generated under. Proofs from any other family
-/// cannot authenticate against it and are rejected.
-pub const VADCOP_FINAL_HASH_FAMILY: &str = "Poseidon1";
+/// Hash family the [`VADCOP_FINAL_VK`] was generated under. Proofs from any other family cannot
+/// authenticate against it and are rejected.
+pub const VADCOP_FINAL_HASH_FAMILY: &str = "blake3";
 
 #[cfg(test)]
 mod tests {
     use std::{io::Read, path::Path};
 
     use flate2::read::GzDecoder;
 
-    use crate::verifier::vk::VADCOP_FINAL_COMPRESSED_VK;
+    use crate::verifier::vk::VADCOP_FINAL_VK;
 
-    /// URL of the proving key of v1.2.0-alpha.
-    const PROVING_KEY_URL: &str =
-        "https://storage.googleapis.com/zisk-setup/zisk-provingkey-1.2.0-alpha.tar.gz";
-    const VK_PATH: &str =
-        "provingKey/zisk/vadcop_final_compressed/vadcop_final_compressed.verkey.bin";
+    /// URL of the blake3 verifying key of v1.3.0-alpha.
+    const VERIFY_KEY_URL: &str =
+        "https://storage.googleapis.com/zisk-setup/zisk-verifykey-1.3.0-alpha-blake3.tar.gz";
+    const VK_PATH: &str = "provingKey/zisk/vadcop_final/vadcop_final.verkey.bin";
 
     #[test]
     fn test_vk_correctness() {
         let response = reqwest::blocking::Client::builder()
             .build()
             .unwrap()
-            .get(PROVING_KEY_URL)
+            .get(VERIFY_KEY_URL)
             .send()
             .unwrap()
             .error_for_status()
@@ -52,7 +51,7 @@ mod tests {
         entry.read_to_end(&mut vk).unwrap();
 
         assert_eq!(
-            VADCOP_FINAL_COMPRESSED_VK
+            VADCOP_FINAL_VK
                 .iter()
                 .flat_map(|word| word.to_le_bytes())
                 .collect::<Vec<_>>(),

crates/verifier/zisk/tests/fixtures/program_vk.bin

@@ -1 +1 @@
-[œG¼Nҝrb#Eš¤~›9¤‰¹ÕÁ¬œÆb6ã
+-œ”wŠÑôàT5ý’_,}iä߸Ÿ+ÎéŒz< 

crates/verifier/zisk/tests/verifier.rs

@@ -85,7 +85,7 @@ fn test_invalid_proof_verify() {
 
 fn proof_with_unexpected_public_values() -> ZiskProof {
     let mut proof = ZiskProof::decode_from_slice(PROOF).unwrap();
-    proof.0.public_values[4] ^= 0xFF;
+    proof.0.public_values[5] ^= 0xFF;
     proof
 }
 

docs/vk-generation.md

@@ -137,9 +137,9 @@ This guide records the encoding for each supported zkVM and gives the commands t
     curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
     . "$HOME/.cargo/env"
 
-    ZKVM_VERSION="v1.2.0-alpha"
+    ZKVM_VERSION="v1.3.0-alpha"
     export ZISK_VERSION=${ZKVM_VERSION#v} SETUP_KEY=proving-no-consttree USE_GPU=false
-    curl -sSf "https://raw.githubusercontent.com/0xPolygonHermez/zisk/$ZKVM_VERSION/ziskup/ziskup" | bash
+    curl -sSf "https://raw.githubusercontent.com/0xPolygonHermez/zisk/$ZKVM_VERSION/ziskup/ziskup" | bash -s -- --blake3
     export PATH="$HOME/.zisk/bin:$PATH"
     ```
 2. Generate VK