Merge pull request #54 from lambdaclass/replace_eprintln_calls

Replace `eprintln!` calls with Logger calls

Author: gabrielbosio

operator/mina/lib/src/lib.rs

@@ -46,26 +46,26 @@ pub extern "C" fn verify_mina_state_ffi(
     pub_input_len: usize,
 ) -> bool {
     let Some(proof_buffer_slice) = proof_buffer.get(..proof_len) else {
-        eprintln!("Proof length argument is greater than max proof size");
+        error!("Proof length argument is greater than max proof size");
         return false;
     };
 
     let Some(pub_input_buffer_slice) = pub_input_buffer.get(..pub_input_len) else {
-        eprintln!("Public input length argument is greater than max public input size");
+        error!("Public input length argument is greater than max public input size");
         return false;
     };
 
     let proof: MinaStateProof = match bincode::deserialize(proof_buffer_slice) {
         Ok(proof) => proof,
         Err(err) => {
-            eprintln!("Failed to deserialize state proof: {}", err);
+            error!("Failed to deserialize state proof: {}", err);
             return false;
         }
     };
     let pub_inputs: MinaStatePubInputs = match bincode::deserialize(pub_input_buffer_slice) {
         Ok(pub_inputs) => pub_inputs,
         Err(err) => {
-            eprintln!("Failed to deserialize state pub inputs: {}", err);
+            error!("Failed to deserialize state pub inputs: {}", err);
             return false;
         }
     };
@@ -75,7 +75,7 @@ pub extern "C" fn verify_mina_state_ffi(
         match check_pub_inputs(&proof, &pub_inputs) {
             Ok(validated_data) => validated_data,
             Err(err) => {
-                eprintln!("Failed to check pub inputs: {err}");
+                error!("Failed to check pub inputs: {err}");
                 return false;
             }
         };
@@ -84,12 +84,12 @@ pub extern "C" fn verify_mina_state_ffi(
     let secure_chain = match select_secure_chain(&candidate_tip_state, &bridge_tip_state) {
         Ok(res) => res,
         Err(err) => {
-            eprintln!("Failed consensus checks for candidate tip: {err}");
+            error!("Failed consensus checks for candidate tip: {err}");
             return false;
         }
     };
     if secure_chain == ChainResult::Bridge {
-        eprintln!("Failed consensus checks for candidate tip: bridge's tip is more secure");
+        error!("Failed consensus checks for candidate tip: bridge's tip is more secure");
         return false;
     }
 

operator/mina_account/lib/src/lib.rs

@@ -1,4 +1,5 @@
 use alloy::sol_types::SolValue;
+use log::error;
 use merkle_verifier::verify_merkle_proof;
 use mina_bridge_core::{
     proof::account_proof::{MinaAccountProof, MinaAccountPubInputs},
@@ -20,12 +21,12 @@ pub extern "C" fn verify_account_inclusion_ffi(
     pub_input_len: usize,
 ) -> bool {
     let Some(proof_buffer_slice) = proof_buffer.get(..proof_len) else {
-        eprintln!("Proof length argument is greater than max proof size");
+        error!("Proof length argument is greater than max proof size");
         return false;
     };
 
     let Some(pub_input_buffer_slice) = pub_input_buffer.get(..pub_input_len) else {
-        eprintln!("Public input length argument is greater than max public input size");
+        error!("Public input length argument is greater than max public input size");
         return false;
     };
 
@@ -35,7 +36,7 @@ pub extern "C" fn verify_account_inclusion_ffi(
     } = match bincode::deserialize(proof_buffer_slice) {
         Ok(proof) => proof,
         Err(err) => {
-            eprintln!("Failed to deserialize account proof: {}", err);
+            error!("Failed to deserialize account proof: {}", err);
             return false;
         }
     };
@@ -45,21 +46,21 @@ pub extern "C" fn verify_account_inclusion_ffi(
     } = match bincode::deserialize(pub_input_buffer_slice) {
         Ok(pub_inputs) => pub_inputs,
         Err(err) => {
-            eprintln!("Failed to deserialize account pub inputs: {}", err);
+            error!("Failed to deserialize account pub inputs: {}", err);
             return false;
         }
     };
 
     let expected_encoded_account = match MinaAccountValidation::Account::try_from(&account) {
         Ok(account) => account,
         Err(err) => {
-            eprintln!("Failed to convert Mina account to Solidity struct: {}", err);
+            error!("Failed to convert Mina account to Solidity struct: {}", err);
             return false;
         }
     }
     .abi_encode();
     if expected_encoded_account != encoded_account {
-        eprintln!("ABI encoded account in public inputs doesn't match the account on the proof");
+        error!("ABI encoded account in public inputs doesn't match the account on the proof");
         return false;
     }