feat: print to stderr any error obtained while executing functions via FFI (#200)

rln/src/ffi.rs

@@ -12,7 +12,15 @@ macro_rules! call {
     ($instance:expr, $method:ident $(, $arg:expr)*) => {
         {
             let new_instance: &mut RLN = $instance.process();
-            new_instance.$method($($arg.process()),*).is_ok()
+            match new_instance.$method($($arg.process()),*) {
+                Ok(()) => {
+                    true
+                }
+                Err(err) => {
+                    eprintln!("execution error: {err}");
+                    false
+                }
+            }
         }
     }
 }
@@ -30,29 +38,37 @@ macro_rules! call_with_output_arg {
         {
             let mut output_data: Vec<u8> = Vec::new();
             let new_instance = $instance.process();
-            if new_instance.$method(&mut output_data).is_ok() {
+            match new_instance.$method(&mut output_data) {
+                Ok(()) => {
                     unsafe { *$output_arg = Buffer::from(&output_data[..]) };
                     std::mem::forget(output_data);
                     true
-            } else {
+                }
+                Err(err) => {
                     std::mem::forget(output_data);
+                    eprintln!("execution error: {err}");
                     false
                 }
             }
+        }
     };
     ($instance:expr, $method:ident, $output_arg:expr, $( $arg:expr ),* ) => {
         {
             let mut output_data: Vec<u8> = Vec::new();
             let new_instance = $instance.process();
-            if new_instance.$method($($arg.process()),*, &mut output_data).is_ok() {
+            match new_instance.$method($($arg.process()),*, &mut output_data) {
+                Ok(()) => {
                     unsafe { *$output_arg = Buffer::from(&output_data[..]) };
                     std::mem::forget(output_data);
                     true
-            } else {
+                }
+                Err(err) => {
                     std::mem::forget(output_data);
+                    eprintln!("execution error: {err}");
                     false
                 }
             }
+        }
     };
 
 }
@@ -66,17 +82,21 @@ macro_rules! no_ctx_call_with_output_arg {
     ($method:ident, $output_arg:expr, $( $arg:expr ),* ) => {
         {
             let mut output_data: Vec<u8> = Vec::new();
-            if $method($($arg.process()),*, &mut output_data).is_ok() {
+            match $method($($arg.process()),*, &mut output_data) {
+                Ok(()) => {
                     unsafe { *$output_arg = Buffer::from(&output_data[..]) };
                     std::mem::forget(output_data);
                     true
-            } else {
+                }
+                Err(err) => {
                     std::mem::forget(output_data);
+                    eprintln!("execution error: {err}");
                     false
                 }
             }
         }
     }
+}
 
 // Macro to call methods with arbitrary amount of arguments,
 // which have the last argument as bool
@@ -89,8 +109,11 @@ macro_rules! call_with_bool_arg {
         {
             let new_instance = $instance.process();
             if match new_instance.$method($($arg.process()),*,) {
-                Ok(verified) => verified,
-                Err(_) => return false,
+                Ok(result) => result,
+                Err(err) => {
+                    eprintln!("execution error: {err}");
+                    return false
+                },
             } {
                 unsafe { *$bool_arg = true };
             } else {
@@ -171,13 +194,17 @@ impl<'a> From<&Buffer> for &'a [u8] {
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn new(tree_height: usize, input_buffer: *const Buffer, ctx: *mut *mut RLN) -> bool {
-    if let Ok(rln) = RLN::new(tree_height, input_buffer.process()) {
+    match RLN::new(tree_height, input_buffer.process()) {
+        Ok(rln) => {
             unsafe { *ctx = Box::into_raw(Box::new(rln)) };
             true
-    } else {
+        }
+        Err(err) => {
+            eprintln!("could not instantiate rln: {err}");
             false
         }
     }
+}
 
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
@@ -189,19 +216,23 @@ pub extern "C" fn new_with_params(
     tree_config: *const Buffer,
     ctx: *mut *mut RLN,
 ) -> bool {
-    if let Ok(rln) = RLN::new_with_params(
+    match RLN::new_with_params(
         tree_height,
         circom_buffer.process().to_vec(),
         zkey_buffer.process().to_vec(),
         vk_buffer.process().to_vec(),
         tree_config.process(),
     ) {
+        Ok(rln) => {
             unsafe { *ctx = Box::into_raw(Box::new(rln)) };
             true
-    } else {
+        }
+        Err(err) => {
+            eprintln!("could not instantiate rln: {err}");
             false
         }
     }
+}
 
 ////////////////////////////////////////////////////////
 // Merkle tree APIs