starknet_api: add PROOF_VERSION_V1 and accept either marker in ProofFactsVariant

Author: Yoni-Starkware

crates/blockifier/src/transaction/account_transactions_test.rs

@@ -2222,7 +2222,7 @@ fn test_missing_validate_entrypoint_rejects(
 /// Converts SnosProofFacts to ProofFacts for testing.
 fn snos_to_proof_facts(snos: SnosProofFacts) -> ProofFacts {
     vec![
-        snos.proof_version,
+        snos.proof_version.as_felt(),
         VIRTUAL_SNOS,
         snos.program_hash,
         VIRTUAL_OS_OUTPUT_VERSION,

crates/starknet_api/src/transaction/fields.rs

@@ -14,6 +14,10 @@ use crate::hash::StarkHash;
 use crate::serde_utils::PrefixedBytesAsHex;
 use crate::{StarknetApiError, StarknetApiResult};
 
+#[cfg(test)]
+#[path = "fields_test.rs"]
+mod fields_test;
+
 pub const HIGH_GAS_AMOUNT: u64 = 10000000000; // A high gas amount that should be enough for execution.
 
 /// A fee.
@@ -633,6 +637,53 @@ pub const VIRTUAL_SNOS: Felt = Felt::from_hex_unchecked("0x5649525455414c5f534e4
 // Represent the `PROOF_VERSION_V0` marker as a Felt ('PROOF0').
 pub const PROOF_VERSION_V0: Felt = Felt::from_hex_unchecked("0x50524f4f4630");
 
+// Represent the `PROOF_VERSION_V1` marker as a Felt ('PROOF1').
+pub const PROOF_VERSION_V1: Felt = Felt::from_hex_unchecked("0x50524f4f4631");
+
+/// Supported proof-facts version markers.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ProofVersion {
+    V0,
+    V1,
+}
+
+impl ProofVersion {
+    /// Felt (Cairo short-string) representation written into proof facts.
+    pub const fn as_felt(self) -> Felt {
+        match self {
+            ProofVersion::V0 => PROOF_VERSION_V0,
+            ProofVersion::V1 => PROOF_VERSION_V1,
+        }
+    }
+
+    /// Human-readable short-string label (matches the Cairo constant value).
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            ProofVersion::V0 => "PROOF0",
+            ProofVersion::V1 => "PROOF1",
+        }
+    }
+}
+
+impl TryFrom<Felt> for ProofVersion {
+    type Error = ();
+    fn try_from(value: Felt) -> Result<Self, Self::Error> {
+        if value == PROOF_VERSION_V0 {
+            Ok(ProofVersion::V0)
+        } else if value == PROOF_VERSION_V1 {
+            Ok(ProofVersion::V1)
+        } else {
+            Err(())
+        }
+    }
+}
+
+impl fmt::Display for ProofVersion {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{} ({})", self.as_felt(), self.as_str())
+    }
+}
+
 /// The version of the virtual OS output (short string 'VIRTUAL_SNOS0').
 /// This must match the Cairo constant `VIRTUAL_OS_OUTPUT_VERSION` in `virtual_os_output.cairo`.
 pub const VIRTUAL_OS_OUTPUT_VERSION: Felt =
@@ -653,6 +704,11 @@ impl ProofFacts {
     pub fn hash(&self) -> Felt {
         HashChain::new().chain_iter(self.0.iter()).get_poseidon_hash()
     }
+
+    /// Returns the proof version marker (first felt). `Felt::ZERO` for empty proof facts.
+    pub fn proof_version_felt(&self) -> Felt {
+        self.0.first().copied().unwrap_or_default()
+    }
 }
 
 /// Represents the variants of proof facts associated with a transaction.
@@ -681,13 +737,17 @@ impl TryFrom<&ProofFacts> for ProofFactsVariant {
             )));
         };
 
-        // Validate that the first element is PROOF_VERSION_V0.
-        if *proof_version != PROOF_VERSION_V0 {
-            return Err(StarknetApiError::InvalidProofFacts(format!(
-                "Expected first field to be {} (PROOF_VERSION_V0), but got {}",
-                PROOF_VERSION_V0, proof_version
-            )));
-        }
+        // Validate that the first element is a supported proof version marker.
+        let proof_version = ProofVersion::try_from(*proof_version).map_err(|()| {
+            StarknetApiError::InvalidProofFacts(format!(
+                "Expected first field to be {} ({}) or {} ({}), but got {}",
+                ProofVersion::V0.as_felt(),
+                ProofVersion::V0.as_str(),
+                ProofVersion::V1.as_felt(),
+                ProofVersion::V1.as_str(),
+                proof_version,
+            ))
+        })?;
 
         // Validate that the second element is VIRTUAL_SNOS.
         if *variant_marker != VIRTUAL_SNOS {
@@ -725,7 +785,7 @@ impl TryFrom<&ProofFacts> for ProofFactsVariant {
         })?);
 
         Ok(ProofFactsVariant::Snos(SnosProofFacts {
-            proof_version: *proof_version,
+            proof_version,
             program_hash: *program_hash,
             block_number,
             block_hash: BlockHash(*block_hash),
@@ -738,7 +798,7 @@ impl TryFrom<&ProofFacts> for ProofFactsVariant {
 ///
 /// A valid SNOS proof facts structure must include these fields as its first five entries.
 pub struct SnosProofFacts {
-    pub proof_version: Felt,
+    pub proof_version: ProofVersion,
     pub program_hash: StarkHash,
     pub block_number: BlockNumber,
     pub block_hash: BlockHash,

crates/starknet_api/src/transaction/fields_test.rs

@@ -0,0 +1,47 @@
+use rstest::rstest;
+
+use super::*;
+
+/// Returns SNOS-shaped `ProofFacts` whose first felt is the given proof version.
+fn proof_facts_given_proof_version(proof_version: Felt) -> ProofFacts {
+    let mut facts = ProofFacts::snos_proof_facts_for_testing();
+    Arc::make_mut(&mut facts.0)[0] = proof_version;
+    facts
+}
+
+#[rstest]
+#[case::v0(ProofVersion::V0)]
+#[case::v1(ProofVersion::V1)]
+fn proof_facts_variant_accepts_supported_versions(#[case] version: ProofVersion) {
+    let variant = ProofFactsVariant::try_from(&proof_facts_given_proof_version(version.as_felt()))
+        .expect("supported version should parse");
+    match variant {
+        ProofFactsVariant::Snos(snos) => assert_eq!(snos.proof_version, version),
+        ProofFactsVariant::Empty => panic!("expected Snos variant"),
+    }
+}
+
+#[test]
+fn proof_facts_variant_rejects_unknown_version() {
+    let facts = proof_facts_given_proof_version(Felt::from_hex_unchecked("0xDEAD"));
+    assert!(matches!(
+        ProofFactsVariant::try_from(&facts),
+        Err(StarknetApiError::InvalidProofFacts(_))
+    ));
+}
+
+/// Encodes a Cairo short-string into a felt (big-endian, right-aligned).
+fn short_string_to_felt(s: &str) -> Felt {
+    let bytes = s.as_bytes();
+    assert!(bytes.len() <= 32, "short string exceeds felt width");
+    let mut padded = [0u8; 32];
+    padded[32 - bytes.len()..].copy_from_slice(bytes);
+    Felt::from_bytes_be(&padded)
+}
+
+#[rstest]
+#[case::v0(ProofVersion::V0)]
+#[case::v1(ProofVersion::V1)]
+fn proof_version_str_encodes_to_felt(#[case] version: ProofVersion) {
+    assert_eq!(short_string_to_felt(version.as_str()), version.as_felt());
+}