feat(cli): add openvm version to STARK/EVM proof jsons (#1986)

Author: jonathanpwang

crates/cli/src/commands/prove.rs

@@ -7,7 +7,7 @@ use openvm_sdk::{
     config::{AggregationTreeConfig, SdkVmConfig},
     fs::{encode_to_file, read_object_from_file, write_to_file_json},
     keygen::AppProvingKey,
-    types::VmStarkProofBytes,
+    types::VersionedVmStarkProof,
     Sdk, F,
 };
 
@@ -159,7 +159,7 @@ impl ProveCmd {
                 println!("vm commit: {:?}", app_commit.app_vm_commit.to_bn254());
 
                 let stark_proof = prover.prove(read_to_stdin(&run_args.input)?)?;
-                let stark_proof_bytes = VmStarkProofBytes::new(stark_proof)?;
+                let stark_proof_bytes = VersionedVmStarkProof::new(stark_proof)?;
 
                 let proof_path = if let Some(proof) = proof {
                     proof

crates/cli/src/commands/verify.rs

@@ -1,12 +1,12 @@
 use std::path::{Path, PathBuf};
 
 use clap::Parser;
-use eyre::Result;
+use eyre::{Context, Result};
 use openvm_sdk::{
     fs::{decode_from_file, read_from_file_json, read_object_from_file},
     prover::verify_app_proof,
-    types::VmStarkProofBytes,
-    Sdk,
+    types::VersionedVmStarkProof,
+    Sdk, OPENVM_VERSION,
 };
 
 use super::KeygenCargoArgs;
@@ -150,12 +150,18 @@ impl VerifyCmd {
                     files[0].clone()
                 };
                 println!("Verifying STARK proof at {}", proof_path.display());
-                let stark_proof_bytes: VmStarkProofBytes = read_from_file_json(proof_path)?;
-                Sdk::verify_proof(&agg_vk, expected_app_commit, &stark_proof_bytes.try_into()?)?;
+                let stark_proof: VersionedVmStarkProof = read_from_file_json(proof_path)
+                    .with_context(|| {
+                        format!("Proof needs to be compatible with openvm v{OPENVM_VERSION}",)
+                    })?;
+                if stark_proof.version != format!("v{OPENVM_VERSION}") {
+                    eprintln!("Attempting to verify proof generated with openvm {}, but the verifier is on openvm v{OPENVM_VERSION}", stark_proof.version);
+                }
+                Sdk::verify_proof(&agg_vk, expected_app_commit, &stark_proof.try_into()?)?;
             }
             #[cfg(feature = "evm-verify")]
             VerifySubCommand::Evm { proof } => {
-                use openvm_sdk::fs::read_evm_halo2_verifier_from_folder;
+                use openvm_sdk::{fs::read_evm_halo2_verifier_from_folder, types::EvmProof};
 
                 let evm_verifier =
                     read_evm_halo2_verifier_from_folder(default_evm_halo2_verifier_path())
@@ -178,7 +184,12 @@ impl VerifyCmd {
                 };
                 // The app config used here doesn't matter, it is ignored in verification
                 println!("Verifying EVM proof at {}", proof_path.display());
-                let evm_proof = read_from_file_json(proof_path)?;
+                let evm_proof: EvmProof = read_from_file_json(proof_path).with_context(|| {
+                    format!("Proof needs to be compatible with openvm v{OPENVM_VERSION}",)
+                })?;
+                if evm_proof.version != format!("v{OPENVM_VERSION}") {
+                    eprintln!("Attempting to verify proof generated with openvm {}, but the verifier is on openvm v{OPENVM_VERSION}", evm_proof.version);
+                }
                 Sdk::verify_evm_halo2_proof(&evm_verifier, evm_proof)?;
             }
         }

crates/sdk/src/types.rs

@@ -18,7 +18,10 @@ use {
     thiserror::Error,
 };
 
-use crate::codec::{decode_vec, encode_slice, Decode, Encode};
+use crate::{
+    codec::{decode_vec, encode_slice, Decode, Encode},
+    OPENVM_VERSION,
+};
 
 /// Number of bytes in a Bn254Fr.
 pub(crate) const BN254_BYTES: usize = 32;
@@ -72,6 +75,9 @@ pub struct ProofData {
 #[serde_as]
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct EvmProof {
+    /// The openvm major and minor version v{}.{}. The proof format will not change on patch
+    /// versions.
+    pub version: String,
     #[serde(flatten)]
     /// Bn254Fr public value app commits.
     pub app_commit: AppExecutionCommit,
@@ -108,6 +114,7 @@ impl EvmProof {
             user_public_values,
             app_commit,
             proof_data,
+            version: _,
         } = self;
 
         let ProofData { accumulator, proof } = proof_data;
@@ -171,6 +178,7 @@ impl TryFrom<RawEvmProof> for EvmProof {
         };
 
         Ok(Self {
+            version: format!("v{}", OPENVM_VERSION),
             app_commit,
             user_public_values,
             proof_data: ProofData {
@@ -189,6 +197,7 @@ impl TryFrom<EvmProof> for RawEvmProof {
             mut app_commit,
             user_public_values,
             proof_data,
+            version: _,
         } = evm_openvm_proof;
 
         app_commit.app_exe_commit.reverse();
@@ -238,28 +247,32 @@ impl TryFrom<EvmProof> for RawEvmProof {
 /// Struct purely for encoding and decoding of [VmStarkProof].
 #[serde_as]
 #[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct VmStarkProofBytes {
+pub struct VersionedVmStarkProof {
+    /// The openvm major and minor version v{}.{}. The proof format will not change on patch
+    /// versions.
+    pub version: String,
     #[serde_as(as = "serde_with::hex::Hex")]
     pub user_public_values: Vec<u8>,
     #[serde_as(as = "serde_with::hex::Hex")]
     pub proof: Vec<u8>,
 }
 
-impl VmStarkProofBytes {
+impl VersionedVmStarkProof {
     pub fn new(proof: VmStarkProof<SC>) -> Result<Self> {
         let mut user_public_values = Vec::new();
         encode_slice(&proof.user_public_values, &mut user_public_values)?;
         Ok(Self {
+            version: format!("v{}", OPENVM_VERSION),
             user_public_values,
             proof: proof.inner.encode_to_vec()?,
         })
     }
 }
 
-impl TryFrom<VmStarkProofBytes> for VmStarkProof<SC> {
+impl TryFrom<VersionedVmStarkProof> for VmStarkProof<SC> {
     type Error = std::io::Error;
-    fn try_from(proof: VmStarkProofBytes) -> Result<Self, std::io::Error> {
-        let VmStarkProofBytes {
+    fn try_from(proof: VersionedVmStarkProof) -> Result<Self, std::io::Error> {
+        let VersionedVmStarkProof {
             proof,
             user_public_values,
             ..