Fix operator for new Mina proof

Author: xqft

operator/mina/lib/Cargo.lock

@@ -26,7 +26,7 @@ bs58 = "0.5.1"
 lazy_static = "1.5.0"
 blake2 = "0.10.6"
 once_cell = "1.19.0"
-core = { git = "https://github.com/lambdaclass/mina_bridge", branch = "relative_finalization" }
+mina_bridge_core = { git = "https://github.com/lambdaclass/mina_bridge", branch = "relative_finalization" }
 bincode = "1.3.3"
 
 [patch.crates-io]

operator/mina/lib/Cargo.toml

@@ -1,6 +1,6 @@
 #include <stdbool.h>
 
-bool verify_protocol_state_proof_ffi(unsigned char *proof_buffer,
-                                     unsigned int proof_len,
-                                     unsigned char *public_input_buffer,
-                                     unsigned int public_input_len);
+bool verify_mina_state_ffi(unsigned char *proof_buffer,
+                            unsigned int proof_len,
+                            unsigned char *pub_input_buffer,
+                            unsigned int pub_input_len);

operator/mina/lib/mina_verifier.h

@@ -1,6 +1,6 @@
 mod consensus_state;
 
-use core::proof::state_proof::{MinaStateProof, MinaStatePubInputs};
+use mina_bridge_core::proof::state_proof::{MinaStateProof, MinaStatePubInputs};
 
 use ark_ec::short_weierstrass_jacobian::GroupAffine;
 use consensus_state::{select_longer_chain, LongerChainResult};
@@ -25,21 +25,21 @@ const MAX_PROOF_SIZE: usize = 48 * 1024;
 const MAX_PUB_INPUT_SIZE: usize = 6 * 1024;
 
 #[no_mangle]
-pub extern "C" fn verify_protocol_state_proof_ffi(
-    proof_bytes: &[u8; MAX_PROOF_SIZE],
+pub extern "C" fn verify_mina_state_ffi(
+    proof_buffer: &[u8; MAX_PROOF_SIZE],
     proof_len: usize,
-    pub_input_bytes: &[u8; MAX_PUB_INPUT_SIZE],
+    pub_input_buffer: &[u8; MAX_PUB_INPUT_SIZE],
     pub_input_len: usize,
 ) -> bool {
-    let proof: MinaStateProof = match bincode::deserialize(&proof_bytes[..proof_len]) {
+    let proof: MinaStateProof = match bincode::deserialize(&proof_buffer[..proof_len]) {
         Ok(proof) => proof,
         Err(err) => {
             eprintln!("Failed to deserialize state proof: {}", err);
             return false;
         }
     };
     let pub_inputs: MinaStatePubInputs =
-        match bincode::deserialize(&pub_input_bytes[..pub_input_len]) {
+        match bincode::deserialize(&pub_input_buffer[..pub_input_len]) {
             Ok(pub_inputs) => pub_inputs,
             Err(err) => {
                 eprintln!("Failed to deserialize state pub inputs: {}", err);
@@ -208,12 +208,8 @@ mod test {
         assert!(pub_input_size <= pub_input_buffer.len());
         pub_input_buffer[..pub_input_size].clone_from_slice(PUB_INPUT_BYTES);
 
-        let result = verify_protocol_state_proof_ffi(
-            &proof_buffer,
-            proof_size,
-            &pub_input_buffer,
-            pub_input_size,
-        );
+        let result =
+            verify_mina_state_ffi(&proof_buffer, proof_size, &pub_input_buffer, pub_input_size);
         assert!(result);
     }
 
@@ -229,12 +225,8 @@ mod test {
         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,
-        );
+        let result =
+            verify_mina_state_ffi(&proof_buffer, proof_size, &pub_input_buffer, pub_input_size);
         assert!(!result);
     }
 

operator/mina/lib/src/lib.rs

@@ -14,7 +14,7 @@ import (
 )
 
 // TODO(xqft): check proof size
-const MAX_PROOF_SIZE = 16 * 1024
+const MAX_PROOF_SIZE = 48 * 1024
 const MAX_PUB_INPUT_SIZE = 6 * 1024
 
 func timer() func() {
@@ -24,9 +24,9 @@ func timer() func() {
 	}
 }
 
-func VerifyProtocolStateProof(proofBuffer [MAX_PROOF_SIZE]byte, proofLen uint, pubInputBuffer [MAX_PUB_INPUT_SIZE]byte, pubInputLen uint) bool {
+func VerifyMinaState(proofBuffer [MAX_PROOF_SIZE]byte, proofLen uint, pubInputBuffer [MAX_PUB_INPUT_SIZE]byte, pubInputLen uint) bool {
 	defer timer()()
 	proofPtr := (*C.uchar)(unsafe.Pointer(&proofBuffer[0]))
 	pubInputPtr := (*C.uchar)(unsafe.Pointer(&pubInputBuffer[0]))
-	return (bool)(C.verify_protocol_state_proof_ffi(proofPtr, (C.uint)(proofLen), pubInputPtr, (C.uint)(pubInputLen)))
+	return (bool)(C.verify_mina_state_ffi(proofPtr, (C.uint)(proofLen), pubInputPtr, (C.uint)(pubInputLen)))
 }

operator/mina/mina.go

@@ -31,7 +31,7 @@ func TestMinaStateProofVerifies(t *testing.T) {
 		t.Errorf("could not read bytes from mina state hash")
 	}
 
-	if !mina.VerifyProtocolStateProof(([mina.MAX_PROOF_SIZE]byte)(proofBuffer), uint(proofLen), ([mina.MAX_PUB_INPUT_SIZE]byte)(pubInputBuffer), uint(pubInputLen)) {
+	if !mina.VerifyMinaState(([mina.MAX_PROOF_SIZE]byte)(proofBuffer), uint(proofLen), ([mina.MAX_PUB_INPUT_SIZE]byte)(pubInputBuffer), uint(pubInputLen)) {
 		t.Errorf("proof did not verify")
 	}
 }

operator/mina/mina_test.go

@@ -365,7 +365,7 @@ func (o *Operator) verify(verificationData VerificationData, results chan bool)
 		pubInputBuffer := make([]byte, mina.MAX_PUB_INPUT_SIZE)
 		copy(pubInputBuffer, verificationData.PubInput)
 
-		verificationResult := mina.VerifyProtocolStateProof(([mina.MAX_PROOF_SIZE]byte)(proofBuffer), proofLen, ([mina.MAX_PUB_INPUT_SIZE]byte)(pubInputBuffer), (uint)(pubInputLen))
+		verificationResult := mina.VerifyMinaState(([mina.MAX_PROOF_SIZE]byte)(proofBuffer), proofLen, ([mina.MAX_PUB_INPUT_SIZE]byte)(pubInputBuffer), (uint)(pubInputLen))
 		o.Logger.Infof("Mina state proof verification result: %t", verificationResult)
 		results <- verificationResult
 	case common.MinaAccount:
@@ -376,7 +376,7 @@ func (o *Operator) verify(verificationData VerificationData, results chan bool)
 		pubInputBuffer := make([]byte, mina.MAX_PUB_INPUT_SIZE)
 		copy(pubInputBuffer, verificationData.PubInput)
 
-		verificationResult := mina_account.VerifyAccountInclusion(([mina.MAX_PROOF_SIZE]byte)(proofBuffer), proofLen, ([mina.MAX_PUB_INPUT_SIZE]byte)(pubInputBuffer), (uint)(pubInputLen))
+		verificationResult := mina_account.VerifyAccountInclusion(([mina_account.MAX_PROOF_SIZE]byte)(proofBuffer), proofLen, ([mina_account.MAX_PUB_INPUT_SIZE]byte)(pubInputBuffer), (uint)(pubInputLen))
 		o.Logger.Infof("Mina account inclusion proof verification result: %t", verificationResult)
 		results <- verificationResult
 	default: