Prepare to receive more public inputs

Author: gabrielbosio

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

@@ -1,6 +1,10 @@
 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 = 2060;
+
 pub fn verify_protocol_state_proof_integrity(proof: &[u8], public_input: &[u8]) -> bool {
     debug!("Checking Mina protocol state proof");
     if let Err(err) = check_protocol_state_proof(proof) {
@@ -30,10 +34,21 @@ 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 protocol_state_base64 =
-        std::str::from_utf8(&protocol_state_pub[32..]).map_err(|err| err.to_string())?;
+    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 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())?;
     BASE64_STANDARD
-        .decode(protocol_state_base64)
+        .decode(tip_protocol_state_base64)
         .map_err(|err| err.to_string())?;
 
     Ok(())

operator/mina/lib/src/lib.rs

@@ -23,7 +23,7 @@ lazy_static! {
 
 // TODO(xqft): check proof size
 const MAX_PROOF_SIZE: usize = 16 * 1024;
-const MAX_PUB_INPUT_SIZE: usize = 3 * 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 = 2060;
@@ -44,10 +44,10 @@ pub extern "C" fn verify_protocol_state_proof_ffi(
     };
 
     let (
-        tip_protocol_state_hash,
-        tip_protocol_state,
         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) => {
@@ -73,7 +73,7 @@ pub extern "C" fn verify_protocol_state_proof_ffi(
 
     if !verify_block(
         &protocol_state_proof,
-        tip_protocol_state_hash,
+        candidate_protocol_state_hash,
         &VERIFIER_INDEX,
         &srs,
     ) {

operator/mina/mina.go

@@ -13,7 +13,7 @@ import (
 
 // TODO(xqft): check proof size
 const MAX_PROOF_SIZE = 16 * 1024
-const MAX_PUB_INPUT_SIZE = 3 * 1024
+const MAX_PUB_INPUT_SIZE = 6 * 1024
 
 func VerifyProtocolStateProof(proofBuffer [MAX_PROOF_SIZE]byte, proofLen uint, pubInputBuffer [MAX_PUB_INPUT_SIZE]byte, pubInputLen uint) bool {
 	proofPtr := (*C.uchar)(unsafe.Pointer(&proofBuffer[0]))