Change order of pub inputs, simplify fns and names

Author: xqft

operator/mina/lib/src/lib.rs

@@ -1,6 +1,6 @@
 mod consensus_state;
 
-use std::array;
+use std::array::{self, TryFromSliceError};
 
 use ark_ec::short_weierstrass_jacobian::GroupAffine;
 use base64::prelude::*;
@@ -35,33 +35,29 @@ pub extern "C" fn verify_protocol_state_proof_ffi(
     public_input_bytes: &[u8; MAX_PUB_INPUT_SIZE],
     public_input_len: usize,
 ) -> bool {
-    let protocol_state_proof = match parse_protocol_state_proof(&proof_bytes[..proof_len]) {
+    let protocol_state_proof = match parse_proof(&proof_bytes[..proof_len]) {
         Ok(protocol_state_proof) => protocol_state_proof,
         Err(err) => {
             eprintln!("Failed to parse protocol state proof: {}", err);
             return false;
         }
     };
 
-    let (
-        candidate_protocol_state_hash,
-        candidate_protocol_state,
-        tip_protocol_state_hash,
-        tip_protocol_state,
-    ) = match parse_protocol_state_pub(&public_input_bytes[..public_input_len]) {
-        Ok(protocol_state_pub) => protocol_state_pub,
-        Err(err) => {
-            eprintln!("Failed to parse protocol state public inputs: {}", err);
-            return false;
-        }
-    };
+    let (candidate_hash, tip_hash, candidate_state, tip_state) =
+        match parse_pub_inputs(&public_input_bytes[..public_input_len]) {
+            Ok(protocol_state_pub) => protocol_state_pub,
+            Err(err) => {
+                eprintln!("Failed to parse protocol state public inputs: {}", err);
+                return false;
+            }
+        };
 
     // TODO(xqft): this can be a batcher's pre-verification check (but don't remove it from here)
-    if MinaHash::hash(&tip_protocol_state) != tip_protocol_state_hash {
+    if MinaHash::hash(&tip_state) != tip_hash {
         eprintln!("The tip's protocol state doesn't match the hash provided as public input");
         return false;
     }
-    if MinaHash::hash(&candidate_protocol_state) != candidate_protocol_state_hash {
+    if MinaHash::hash(&candidate_state) != candidate_hash {
         eprintln!("The candidate's protocol state doesn't match the hash provided as public input");
         return false;
     }
@@ -72,115 +68,104 @@ pub extern "C" fn verify_protocol_state_proof_ffi(
     let srs = srs.lock().unwrap();
 
     // Consensus check: Short fork rule
-    let longer_chain = select_longer_chain(&candidate_protocol_state, &tip_protocol_state);
+    let longer_chain = select_longer_chain(&candidate_state, &tip_state);
     if longer_chain == LongerChainResult::Tip {
         eprintln!("Consensus check failed");
         return false;
     }
 
     // Pickles verification
-    verify_block(
-        &protocol_state_proof,
-        candidate_protocol_state_hash,
-        &VERIFIER_INDEX,
-        &srs,
-    )
+    verify_block(&protocol_state_proof, candidate_hash, &VERIFIER_INDEX, &srs)
 }
 
-pub fn parse_protocol_state_proof(
-    protocol_state_proof_bytes: &[u8],
-) -> Result<MinaBaseProofStableV2, String> {
-    let protocol_state_proof_base64 =
-        std::str::from_utf8(protocol_state_proof_bytes).map_err(|err| err.to_string())?;
-    let protocol_state_proof_binprot = BASE64_URL_SAFE
-        .decode(protocol_state_proof_base64)
-        .map_err(|err| err.to_string())?;
-    MinaBaseProofStableV2::binprot_read(&mut protocol_state_proof_binprot.as_slice())
-        .map_err(|err| err.to_string())
+pub fn parse_hash(pub_inputs: &[u8], offset: &mut usize) -> Result<Fp, String> {
+    let hash = pub_inputs
+        .get(*offset..*offset + STATE_HASH_SIZE)
+        .ok_or("Failed to slice candidate hash".to_string())
+        .and_then(|bytes| Fp::from_bytes(bytes).map_err(|err| err.to_string()))?;
+
+    *offset += STATE_HASH_SIZE;
+
+    Ok(hash)
+}
+
+pub fn parse_state(
+    pub_inputs: &[u8],
+    offset: &mut usize,
+) -> Result<MinaStateProtocolStateValueStableV2, String> {
+    let state_len: usize = pub_inputs
+        .get(*offset..*offset + 4)
+        .ok_or("Failed to slice  state len".to_string())
+        .and_then(|slice| {
+            slice
+                .try_into()
+                .map_err(|err: TryFromSliceError| err.to_string())
+        })
+        .map(u32::from_be_bytes)
+        .and_then(|len| usize::try_from(len).map_err(|err| err.to_string()))?;
+
+    let state = pub_inputs
+        .get(*offset + 4..*offset + 4 + state_len)
+        .ok_or("Failed to slice  state".to_string())
+        .and_then(|bytes| std::str::from_utf8(bytes).map_err(|err| err.to_string()))
+        .and_then(|base64| {
+            BASE64_STANDARD
+                .decode(base64)
+                .map_err(|err| err.to_string())
+        })
+        .and_then(|binprot| {
+            MinaStateProtocolStateValueStableV2::binprot_read(&mut binprot.as_slice())
+                .map_err(|err| err.to_string())
+        })?;
+
+    *offset += 4 + state_len;
+
+    Ok(state)
 }
 
-pub fn parse_protocol_state_pub(
-    protocol_state_pub: &[u8],
+pub fn parse_pub_inputs(
+    pub_inputs: &[u8],
 ) -> Result<
     (
         Fp,
-        MinaStateProtocolStateValueStableV2,
         Fp,
         MinaStateProtocolStateValueStableV2,
+        MinaStateProtocolStateValueStableV2,
     ),
     String,
 > {
-    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, candidate_start)?;
-
-    Ok((
-        tip_protocol_state_hash,
-        tip_protocol_state,
-        candidate_protocol_state_hash,
-        candidate_protocol_state,
-    ))
+    let mut offset = 0;
+
+    let candidate_hash = parse_hash(pub_inputs, &mut offset)?;
+    let tip_hash = parse_hash(pub_inputs, &mut offset)?;
+
+    let candidate_state = parse_state(pub_inputs, &mut offset)?;
+    let tip_state = parse_state(pub_inputs, &mut offset)?;
+
+    Ok((candidate_hash, tip_hash, candidate_state, tip_state))
 }
 
-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_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_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,
-        start + STATE_HASH_SIZE + 4 + protocol_state_len,
-    ))
+pub fn parse_proof(proof_bytes: &[u8]) -> Result<MinaBaseProofStableV2, String> {
+    std::str::from_utf8(proof_bytes)
+        .map_err(|err| err.to_string())
+        .and_then(|base64| {
+            BASE64_URL_SAFE
+                .decode(base64)
+                .map_err(|err| err.to_string())
+        })
+        .and_then(|binprot| {
+            MinaBaseProofStableV2::binprot_read(&mut binprot.as_slice())
+                .map_err(|err| err.to_string())
+        })
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
 
-    const PROTOCOL_STATE_PROOF_BYTES: &[u8] =
+    const PROOF_BYTES: &[u8] =
         include_bytes!("../../../../batcher/aligned/test_files/mina/protocol_state.proof");
-    const PROTOCOL_STATE_PUB_BYTES: &[u8] =
+    const PUB_INPUT_BYTES: &[u8] =
         include_bytes!("../../../../batcher/aligned/test_files/mina/protocol_state.pub");
     const PROTOCOL_STATE_BAD_HASH_PUB_BYTES: &[u8] =
         include_bytes!("../../../../batcher/aligned/test_files/mina/protocol_state_bad_hash.pub");
@@ -190,25 +175,25 @@ mod test {
 
     #[test]
     fn parse_protocol_state_proof_does_not_fail() {
-        parse_protocol_state_proof(PROTOCOL_STATE_PROOF_BYTES).unwrap();
+        parse_proof(PROOF_BYTES).unwrap();
     }
 
     #[test]
     fn parse_protocol_state_pub_does_not_fail() {
-        parse_protocol_state_pub(PROTOCOL_STATE_PUB_BYTES).unwrap();
+        parse_pub_inputs(PUB_INPUT_BYTES).unwrap();
     }
 
     #[test]
     fn protocol_state_proof_verifies() {
         let mut proof_buffer = [0u8; super::MAX_PROOF_SIZE];
-        let proof_size = PROTOCOL_STATE_PROOF_BYTES.len();
+        let proof_size = PROOF_BYTES.len();
         assert!(proof_size <= proof_buffer.len());
-        proof_buffer[..proof_size].clone_from_slice(PROTOCOL_STATE_PROOF_BYTES);
+        proof_buffer[..proof_size].clone_from_slice(PROOF_BYTES);
 
         let mut pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
-        let pub_input_size = PROTOCOL_STATE_PUB_BYTES.len();
+        let pub_input_size = PUB_INPUT_BYTES.len();
         assert!(pub_input_size <= pub_input_buffer.len());
-        pub_input_buffer[..pub_input_size].clone_from_slice(PROTOCOL_STATE_PUB_BYTES);
+        pub_input_buffer[..pub_input_size].clone_from_slice(PUB_INPUT_BYTES);
 
         let result = verify_protocol_state_proof_ffi(
             &proof_buffer,
@@ -222,9 +207,9 @@ mod test {
     #[test]
     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();
+        let proof_size = PROOF_BYTES.len();
         assert!(proof_size <= proof_buffer.len());
-        proof_buffer[..proof_size].clone_from_slice(PROTOCOL_STATE_PROOF_BYTES);
+        proof_buffer[..proof_size].clone_from_slice(PROOF_BYTES);
 
         let mut pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
         let pub_input_size = PROTOCOL_STATE_BAD_HASH_PUB_BYTES.len();
@@ -243,9 +228,9 @@ mod test {
     #[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();
+        let proof_size = PROOF_BYTES.len();
         assert!(proof_size <= proof_buffer.len());
-        proof_buffer[..proof_size].clone_from_slice(PROTOCOL_STATE_PROOF_BYTES);
+        proof_buffer[..proof_size].clone_from_slice(PROOF_BYTES);
 
         let mut pub_input_buffer = [0u8; super::MAX_PUB_INPUT_SIZE];
         let pub_input_size = PROTOCOL_STATE_BAD_CONSENSUS_PUB_BYTES.len();