Free memory from rust -> dart

binding.h

@@ -13,10 +13,14 @@ typedef void *DartPostCObjectFnType;
 
 void dummy_export(void);
 
+void deallocate_str(char *s);
+
 void dart_post_cobject(DartPostCObjectFnType ptr);
 
 bool get_error(void);
 
+char *get_error_msg(void);
+
 void init_wallet(char *db_path);
 
 void set_active(uint8_t active);
@@ -94,7 +98,7 @@ char *generate_random_enc_key(void);
 
 char *get_full_backup(char *key);
 
-char *restore_full_backup(char *key, char *backup);
+void restore_full_backup(char *key, char *backup);
 
 char *split_data(uint32_t id, char *data);
 

src/api/dart_ffi.rs

@@ -1,12 +1,11 @@
 use crate::coinconfig::{init_coin, CoinConfig};
-use crate::FountainCodes;
 use crate::{ChainError, Tx};
 use allo_isolate::{ffi, IntoDart};
 use android_logger::Config;
 use lazy_static::lazy_static;
 use log::Level;
+use std::cell::RefCell;
 use std::ffi::{CStr, CString};
-use std::io::Read;
 use std::os::raw::c_char;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Mutex;
@@ -15,6 +14,10 @@ use zcash_primitives::transaction::builder::Progress;
 static mut POST_COBJ: Option<ffi::DartPostCObjectFnType> = None;
 static IS_ERROR: AtomicBool = AtomicBool::new(false);
 
+lazy_static! {
+    static ref LAST_ERROR: Mutex<RefCell<String>> = Mutex::new(RefCell::new(String::new()));
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dummy_export() {}
 
@@ -33,6 +36,11 @@ fn to_c_str(s: String) -> *mut c_char {
     CString::new(s).unwrap().into_raw()
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn deallocate_str(s: *mut c_char) {
+    let _ = CString::from_raw(s);
+}
+
 fn try_init_logger() {
     android_logger::init_once(
         Config::default()
@@ -53,9 +61,15 @@ fn log_result<T: Default>(result: anyhow::Result<T>) -> T {
     match result {
         Err(err) => {
             log::error!("{}", err);
+            let last_error = LAST_ERROR.lock().unwrap();
+            last_error.replace(err.to_string());
+            IS_ERROR.store(true, Ordering::Release);
             T::default()
         }
-        Ok(v) => v,
+        Ok(v) => {
+            IS_ERROR.store(false, Ordering::Release);
+            v
+        }
     }
 }
 
@@ -63,6 +77,8 @@ fn log_string(result: anyhow::Result<String>) -> String {
     match result {
         Err(err) => {
             log::error!("{}", err);
+            let last_error = LAST_ERROR.lock().unwrap();
+            last_error.replace(err.to_string());
             IS_ERROR.store(true, Ordering::Release);
             format!("{}", err)
         }
@@ -78,6 +94,13 @@ pub unsafe extern "C" fn get_error() -> bool {
     IS_ERROR.load(Ordering::Acquire)
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn get_error_msg() -> *mut c_char {
+    let error = LAST_ERROR.lock().unwrap();
+    let e = error.take();
+    to_c_str(e)
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn init_wallet(db_path: *mut c_char) {
     try_init_logger();
@@ -480,7 +503,7 @@ pub unsafe extern "C" fn get_full_backup(key: *mut c_char) -> *mut c_char {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn restore_full_backup(key: *mut c_char, backup: *mut c_char) -> *mut c_char {
+pub unsafe extern "C" fn restore_full_backup(key: *mut c_char, backup: *mut c_char) {
     from_c_str!(key);
     from_c_str!(backup);
     let res = || {
@@ -488,9 +511,9 @@ pub unsafe extern "C" fn restore_full_backup(key: *mut c_char, backup: *mut c_ch
         for coin in [0, 1] {
             crate::api::fullbackup::restore_full_backup(coin, &accounts)?;
         }
-        Ok(String::new())
+        Ok(())
     };
-    to_c_str(log_string(res()))
+    log_result(res())
 }
 
 #[no_mangle]

src/fountain.rs

@@ -3,7 +3,6 @@ use blake2b_simd::Params;
 use byteorder::{ReadBytesExt, WriteBytesExt, LE};
 use raptorq::{Decoder, Encoder, EncodingPacket, ObjectTransmissionInformation};
 use serde::Serialize;
-use std::borrow::BorrowMut;
 use std::convert::TryInto;
 use std::io::{Cursor, Write};
 

src/pay.rs

@@ -427,18 +427,8 @@ pub async fn broadcast_tx(tx: &[u8]) -> anyhow::Result<String> {
 }
 
 pub fn get_tx_summary(tx: &Tx) -> anyhow::Result<TxSummary> {
-    let mut amount = 0;
-    for tx_in in tx.t_inputs.iter() {
-        // transparent inputs
-        amount += tx_in.amount;
-    }
-    for tx_in in tx.inputs.iter() {
-        // shielded inputs
-        amount += tx_in.amount;
-    }
     let mut recipients = vec![];
     for tx_out in tx.outputs.iter() {
-        amount -= tx_out.amount;
         recipients.push(RecipientSummary {
             address: tx_out.addr.clone(),
             amount: tx_out.amount,