Merge pull request #16 from lambdaclass/state_size_in_pub_input

State size in protocol state public input

Author: gabrielbosio

Makefile

@@ -401,6 +401,14 @@ batcher_send_mina_task_bad_hash:
 		--public_input test_files/mina/protocol_state_bad_hash.pub \
 		--proof_generator_addr 0x66f9664f97F2b50F62D13eA064982f936dE76657
 
+batcher_send_mina_task_bad_consensus:
+	@echo "Sending Mina state task to Batcher..."
+	@cd batcher/aligned/ && cargo run --release -- submit \
+		--proving_system Mina \
+		--proof test_files/mina/protocol_state.proof \
+		--public_input test_files/mina/protocol_state_bad_consensus.pub \
+		--proof_generator_addr 0x66f9664f97F2b50F62D13eA064982f936dE76657
+
 batcher_send_mina_burst:
 	@echo "Sending Mina state task to Batcher..."
 	@cd batcher/aligned/ && cargo run --release -- submit \

batcher/aligned-batcher/src/mina/mod.rs

@@ -1,15 +1,11 @@
+use std::array;
+
 use base64::prelude::*;
 use log::{debug, warn};
 
 const STATE_HASH_SIZE: usize = 32;
-// TODO(gabrielbosio): check that this length is always the same for every block
-const PROTOCOL_STATE_SIZE: usize = 2056;
 
 pub fn verify_protocol_state_proof_integrity(proof: &[u8], public_input: &[u8]) -> bool {
-    if public_input.len() != (STATE_HASH_SIZE + PROTOCOL_STATE_SIZE) * 2 {
-        return false;
-    }
-
     debug!("Checking Mina protocol state proof");
     if let Err(err) = check_protocol_state_proof(proof) {
         warn!("Protocol state proof check failed: {}", err);
@@ -38,24 +34,35 @@ pub fn check_protocol_state_proof(protocol_state_proof_bytes: &[u8]) -> Result<(
 
 pub fn check_protocol_state_pub(protocol_state_pub: &[u8]) -> Result<(), String> {
     // TODO(xqft): check hash and binprot deserialization
-    let candidate_protocol_state_base64 = std::str::from_utf8(
-        &protocol_state_pub[STATE_HASH_SIZE..(STATE_HASH_SIZE + PROTOCOL_STATE_SIZE)],
-    )
-    .map_err(|err| err.to_string())?;
-    BASE64_STANDARD
-        .decode(candidate_protocol_state_base64)
-        .map_err(|err| err.to_string())?;
+    let candidate_protocol_state_len =
+        check_protocol_state_and_hash(protocol_state_pub, STATE_HASH_SIZE)?;
 
-    let tip_protocol_state_base64 = std::str::from_utf8(
-        &protocol_state_pub[(STATE_HASH_SIZE + PROTOCOL_STATE_SIZE) + STATE_HASH_SIZE
-            ..((STATE_HASH_SIZE + PROTOCOL_STATE_SIZE) * 2)],
-    )
-    .map_err(|err| err.to_string())?;
+    let _tip_protocol_state_len = check_protocol_state_and_hash(
+        protocol_state_pub,
+        STATE_HASH_SIZE + 4 + candidate_protocol_state_len + STATE_HASH_SIZE,
+    )?;
+
+    Ok(())
+}
+
+fn check_protocol_state_and_hash(protocol_state_pub: &[u8], start: usize) -> Result<usize, String> {
+    let protocol_state_len_vec: Vec<_> = protocol_state_pub.iter().skip(start).take(4).collect();
+    let protocol_state_len_bytes: [u8; 4] = array::from_fn(|i| protocol_state_len_vec[i].clone());
+    let protocol_state_len = u32::from_be_bytes(protocol_state_len_bytes) as usize;
+
+    let protocol_state_bytes: Vec<_> = protocol_state_pub
+        .iter()
+        .skip(start + 4)
+        .take(protocol_state_len)
+        .map(|byte| byte.clone())
+        .collect();
+    let protocol_state_base64 =
+        std::str::from_utf8(protocol_state_bytes.as_slice()).map_err(|err| err.to_string())?;
     BASE64_STANDARD
-        .decode(tip_protocol_state_base64)
+        .decode(protocol_state_base64)
         .map_err(|err| err.to_string())?;
 
-    Ok(())
+    Ok(protocol_state_len)
 }
 
 #[cfg(test)]

batcher/aligned/test_files/mina/protocol_state.proof

@@ -1,5 +1,7 @@
 mod consensus_state;
 
+use std::array;
+
 use ark_ec::short_weierstrass_jacobian::GroupAffine;
 use base64::prelude::*;
 use consensus_state::{select_longer_chain, LongerChainResult};
@@ -24,9 +26,7 @@ lazy_static! {
 // TODO(xqft): check proof size
 const MAX_PROOF_SIZE: usize = 16 * 1024;
 const MAX_PUB_INPUT_SIZE: usize = 6 * 1024;
-const PROTOCOL_STATE_HASH_SIZE: usize = 32;
-// TODO(gabrielbosio): check that this length is always the same for every block
-const PROTOCOL_STATE_SIZE: usize = 2056;
+const STATE_HASH_SIZE: usize = 32;
 
 #[no_mangle]
 pub extern "C" fn verify_protocol_state_proof_ffi(
@@ -110,14 +110,11 @@ pub fn parse_protocol_state_pub(
     ),
     String,
 > {
-    let (tip_protocol_state_hash, tip_protocol_state) = parse_protocol_state_with_hash(
-        &protocol_state_pub[..(PROTOCOL_STATE_HASH_SIZE + PROTOCOL_STATE_SIZE)],
-    )?;
+    let (tip_protocol_state_hash, tip_protocol_state, candidate_start) =
+        parse_protocol_state_with_hash(&protocol_state_pub, 0)?;
 
-    let (candidate_protocol_state_hash, candidate_protocol_state) = parse_protocol_state_with_hash(
-        &protocol_state_pub[(PROTOCOL_STATE_HASH_SIZE + PROTOCOL_STATE_SIZE)
-            ..((PROTOCOL_STATE_HASH_SIZE + PROTOCOL_STATE_SIZE) * 2)],
-    )?;
+    let (candidate_protocol_state_hash, candidate_protocol_state, _) =
+        parse_protocol_state_with_hash(&protocol_state_pub, candidate_start)?;
 
     Ok((
         tip_protocol_state_hash,
@@ -129,25 +126,52 @@ pub fn parse_protocol_state_pub(
 
 fn parse_protocol_state_with_hash(
     protocol_state_pub: &[u8],
+    start: usize,
 ) -> Result<
     (
         ark_ff::Fp256<mina_curves::pasta::fields::FpParameters>,
         MinaStateProtocolStateValueStableV2,
+        usize,
     ),
     String,
 > {
+    let protocol_state_hash_bytes: Vec<_> = protocol_state_pub
+        .iter()
+        .skip(start)
+        .take(STATE_HASH_SIZE)
+        .map(|byte| byte.clone())
+        .collect();
     let protocol_state_hash =
-        Fp::from_bytes(&protocol_state_pub[..32]).map_err(|err| err.to_string())?;
+        Fp::from_bytes(&protocol_state_hash_bytes).map_err(|err| err.to_string())?;
+
+    let protocol_state_len_vec: Vec<_> = protocol_state_pub
+        .iter()
+        .skip(start + STATE_HASH_SIZE)
+        .take(8)
+        .collect();
+    let protocol_state_len_bytes: [u8; 4] = array::from_fn(|i| protocol_state_len_vec[i].clone());
+    let protocol_state_len = u32::from_be_bytes(protocol_state_len_bytes) as usize;
+
+    let protocol_state_bytes: Vec<_> = protocol_state_pub
+        .iter()
+        .skip(start + STATE_HASH_SIZE + 4)
+        .take(protocol_state_len)
+        .map(|byte| byte.clone())
+        .collect();
     let protocol_state_base64 =
-        std::str::from_utf8(&protocol_state_pub[32..]).map_err(|err| err.to_string())?;
+        std::str::from_utf8(&protocol_state_bytes).map_err(|err| err.to_string())?;
     let protocol_state_binprot = BASE64_STANDARD
         .decode(protocol_state_base64)
         .map_err(|err| err.to_string())?;
     let protocol_state =
         MinaStateProtocolStateValueStableV2::binprot_read(&mut protocol_state_binprot.as_slice())
             .map_err(|err| err.to_string())?;
 
-    Ok((protocol_state_hash, protocol_state))
+    Ok((
+        protocol_state_hash,
+        protocol_state,
+        start + STATE_HASH_SIZE + 4 + protocol_state_len,
+    ))
 }
 
 #[cfg(test)]
@@ -158,9 +182,11 @@ mod test {
         include_bytes!("../../../../batcher/aligned/test_files/mina/protocol_state.proof");
     const PROTOCOL_STATE_PUB_BYTES: &[u8] =
         include_bytes!("../../../../batcher/aligned/test_files/mina/protocol_state.pub");
-    const BAD_PROTOCOL_STATE_PUB_BYTES: &[u8] =
-        include_bytes!("../../../../batcher/aligned/test_files/mina/bad_protocol_state.pub");
-    // BAD_PROTOCOL_STATE_PUB_BYTES has an invalid hash.
+    const PROTOCOL_STATE_BAD_HASH_PUB_BYTES: &[u8] =
+        include_bytes!("../../../../batcher/aligned/test_files/mina/protocol_state_bad_hash.pub");
+    const PROTOCOL_STATE_BAD_CONSENSUS_PUB_BYTES: &[u8] = include_bytes!(
+        "../../../../batcher/aligned/test_files/mina/protocol_state_bad_consensus.pub"
+    );
 
     #[test]
     fn parse_protocol_state_proof_does_not_fail() {
@@ -194,16 +220,37 @@ mod test {
     }
 
     #[test]
-    fn bad_protocol_state_proof_does_not_verify() {
+    fn proof_of_protocol_state_with_bad_hash_does_not_verify() {
+        let mut proof_buffer = [0u8; super::MAX_PROOF_SIZE];
+        let proof_size = PROTOCOL_STATE_PROOF_BYTES.len();
+        assert!(proof_size <= proof_buffer.len());
+        proof_buffer[..proof_size].clone_from_slice(PROTOCOL_STATE_PROOF_BYTES);
+
+        let mut pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
+        let pub_input_size = PROTOCOL_STATE_BAD_HASH_PUB_BYTES.len();
+        assert!(pub_input_size <= pub_input_buffer.len());
+        pub_input_buffer[..pub_input_size].clone_from_slice(PROTOCOL_STATE_BAD_HASH_PUB_BYTES);
+
+        let result = verify_protocol_state_proof_ffi(
+            &proof_buffer,
+            proof_size,
+            &pub_input_buffer,
+            pub_input_size,
+        );
+        assert!(!result);
+    }
+
+    #[test]
+    fn proof_of_protocol_state_with_bad_consensus_does_not_verify() {
         let mut proof_buffer = [0u8; super::MAX_PROOF_SIZE];
         let proof_size = PROTOCOL_STATE_PROOF_BYTES.len();
         assert!(proof_size <= proof_buffer.len());
         proof_buffer[..proof_size].clone_from_slice(PROTOCOL_STATE_PROOF_BYTES);
 
         let mut pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
-        let pub_input_size = BAD_PROTOCOL_STATE_PUB_BYTES.len();
+        let pub_input_size = PROTOCOL_STATE_BAD_CONSENSUS_PUB_BYTES.len();
         assert!(pub_input_size <= pub_input_buffer.len());
-        pub_input_buffer[..pub_input_size].clone_from_slice(BAD_PROTOCOL_STATE_PUB_BYTES);
+        pub_input_buffer[..pub_input_size].clone_from_slice(PROTOCOL_STATE_BAD_CONSENSUS_PUB_BYTES);
 
         let result = verify_protocol_state_proof_ffi(
             &proof_buffer,