Make Transaction Field in V4 Slate Optional (#356)

* make transaction field in V4 Slate optional

* add mutable/non mutable version of tx getter

* removal of mut references where not needed

* remove more muts

* update from master

* update from master

* test fixes

controller/src/command.rs

@@ -374,7 +374,7 @@ where
 				e
 			})?;
 			slate = api.finalize_tx(m, &slate)?;
-			let result = api.post_tx(m, &slate.tx, args.fluff);
+			let result = api.post_tx(m, slate.tx_or_err()?, args.fluff);
 			match result {
 				Ok(_) => {
 					info!("Tx sent ok",);
@@ -477,7 +477,7 @@ where
 				error!("Error validating participant messages: {}", e);
 				return Err(e);
 			}
-			slate = api.finalize_invoice_tx(&mut slate)?;
+			slate = api.finalize_invoice_tx(&slate)?;
 			Ok(())
 		})?;
 	} else {
@@ -486,14 +486,14 @@ where
 				error!("Error validating participant messages: {}", e);
 				return Err(e);
 			}
-			slate = api.finalize_tx(m, &mut slate)?;
+			slate = api.finalize_tx(m, &slate)?;
 			Ok(())
 		})?;
 	}
 
 	if !args.nopost {
 		controller::owner_single_use(None, keychain_mask, Some(owner_api), |api, m| {
-			let result = api.post_tx(m, &slate.tx, args.fluff);
+			let result = api.post_tx(m, slate.tx_or_err()?, args.fluff);
 			match result {
 				Ok(_) => {
 					info!(
@@ -798,7 +798,7 @@ where
 	let slate = PathToSlate((&args.input).into()).get_tx()?;
 
 	controller::owner_single_use(None, keychain_mask, Some(owner_api), |api, m| {
-		api.post_tx(m, &slate.tx, args.fluff)?;
+		api.post_tx(m, slate.tx_or_err()?, args.fluff)?;
 		info!("Posted transaction");
 		return Ok(());
 	})?;

controller/src/controller.rs

@@ -397,7 +397,7 @@ impl OwnerV3Helpers {
 	/// Update the shared mask, in case of foreign API being run
 	pub fn update_mask(mask: Arc<Mutex<Option<SecretKey>>>, val: &serde_json::Value) {
 		if let Some(key) = val["result"]["Ok"].as_str() {
-			let key_bytes = match from_hex(key.to_owned()) {
+			let key_bytes = match from_hex(key) {
 				Ok(k) => k,
 				Err(_) => return,
 			};

controller/tests/accounts.rs

@@ -202,7 +202,7 @@ fn accounts_test_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
 		slate = client1.send_tx_slate_direct("wallet2", &slate)?;
 		api.tx_lock_outputs(m, &slate, 0)?;
 		slate = api.finalize_tx(m, &slate)?;
-		api.post_tx(m, &slate.tx, false)?;
+		api.post_tx(m, slate.tx_or_err()?, false)?;
 		Ok(())
 	})?;
 

controller/tests/file.rs

@@ -122,9 +122,9 @@ fn file_exchange_test_impl(test_dir: &'static str) -> Result<(), libwallet::Erro
 			message: Some(message.to_owned()),
 			..Default::default()
 		};
-		let mut slate = api.init_send_tx(m, args)?;
+		let slate = api.init_send_tx(m, args)?;
 		// output tx file
-		PathToSlate((&send_file).into()).put_tx(&mut slate)?;
+		PathToSlate((&send_file).into()).put_tx(&slate)?;
 		api.tx_lock_outputs(m, &slate, 0)?;
 		Ok(())
 	})?;
@@ -160,7 +160,7 @@ fn file_exchange_test_impl(test_dir: &'static str) -> Result<(), libwallet::Erro
 		let mut slate = PathToSlate(receive_file.into()).get_tx()?;
 		api.verify_slate_messages(m, &slate)?;
 		slate = api.finalize_tx(m, &slate)?;
-		api.post_tx(m, &slate.tx, false)?;
+		api.post_tx(m, slate.tx_or_err()?, false)?;
 		bh += 1;
 		Ok(())
 	})?;

controller/tests/invoice.rs

@@ -132,7 +132,7 @@ fn invoice_tx_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
 
 	// wallet 1 posts so wallet 2 doesn't get the mined amount
 	wallet::controller::owner_single_use(Some(wallet1.clone()), mask1, None, |api, m| {
-		api.post_tx(m, &slate.tx, false)?;
+		api.post_tx(m, slate.tx_or_err()?, false)?;
 		Ok(())
 	})?;
 	bh += 1;

controller/tests/no_change.rs

@@ -91,7 +91,7 @@ fn no_change_test_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
 		slate = client1.send_tx_slate_direct("wallet2", &slate)?;
 		api.tx_lock_outputs(m, &slate, 0)?;
 		slate = api.finalize_tx(m, &slate)?;
-		api.post_tx(m, &slate.tx, false)?;
+		api.post_tx(m, slate.tx_or_err()?, false)?;
 		Ok(())
 	})?;
 
@@ -139,7 +139,7 @@ fn no_change_test_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
 		Ok(())
 	})?;
 	wallet::controller::owner_single_use(Some(wallet2.clone()), mask1, None, |api, m| {
-		api.post_tx(m, &slate.tx, false)?;
+		api.post_tx(m, slate.tx_or_err()?, false)?;
 		Ok(())
 	})?;
 

controller/tests/payment_proofs.rs

@@ -135,7 +135,7 @@ fn payment_proofs_test_impl(test_dir: &'static str) -> Result<(), libwallet::Err
 		assert!(pp.is_err());
 
 		slate = sender_api.finalize_tx(m, &slate)?;
-		sender_api.post_tx(m, &slate.tx, true)?;
+		sender_api.post_tx(m, slate.tx_or_err()?, true)?;
 		Ok(())
 	})?;
 

controller/tests/repost.rs

@@ -213,7 +213,7 @@ fn file_repost_test_impl(test_dir: &'static str) -> Result<(), libwallet::Error>
 		let slate_i = sender_api.init_send_tx(m, args)?;
 		slate = client1.send_tx_slate_direct("wallet2", &slate_i)?;
 		sender_api.tx_lock_outputs(m, &slate, 0)?;
-		slate = sender_api.finalize_tx(m, &mut slate)?;
+		slate = sender_api.finalize_tx(m, &slate)?;
 		Ok(())
 	})?;
 

controller/tests/revert.rs

@@ -207,8 +207,13 @@ fn revert(
 
 	// Build 2 blocks at same height: 1 with the tx, 1 without
 	let head = chain.head_header().unwrap();
-	let block_with =
-		create_block_for_wallet(&chain, head.clone(), vec![&tx], wallet1.clone(), mask1)?;
+	let block_with = create_block_for_wallet(
+		&chain,
+		head.clone(),
+		vec![&tx.as_ref().unwrap()],
+		wallet1.clone(),
+		mask1,
+	)?;
 	let block_without = create_block_for_wallet(&chain, head, vec![], wallet1.clone(), mask1)?;
 
 	// Add block with tx to the chain
@@ -277,7 +282,15 @@ fn revert(
 
 	stopper2.store(false, Ordering::Relaxed);
 	Ok((
-		chain, stopper, sent, bh, tx, wallet1, mask1_i, wallet2, mask2_i,
+		chain,
+		stopper,
+		sent,
+		bh,
+		tx.unwrap(),
+		wallet1,
+		mask1_i,
+		wallet2,
+		mask2_i,
 	))
 }
 

controller/tests/self_send.rs

@@ -101,7 +101,7 @@ fn self_send_test_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
 			Ok(())
 		})?;
 		slate = api.finalize_tx(m, &slate)?;
-		api.post_tx(m, &slate.tx, false)?; // mines a block
+		api.post_tx(m, slate.tx_or_err()?, false)?; // mines a block
 		bh += 1;
 		Ok(())
 	})?;

controller/tests/transaction.rs

@@ -120,9 +120,14 @@ fn basic_transaction_api(test_dir: &'static str) -> Result<(), libwallet::Error>
 		slate = sender_api.finalize_tx(m, &slate)?;
 
 		// Check we have a single kernel and that it is a Plain kernel (no lock_height).
-		assert_eq!(slate.tx.kernels().len(), 1);
+		assert_eq!(slate.tx_or_err()?.kernels().len(), 1);
 		assert_eq!(
-			slate.tx.kernels().first().map(|k| k.features).unwrap(),
+			slate
+				.tx_or_err()?
+				.kernels()
+				.first()
+				.map(|k| k.features)
+				.unwrap(),
 			transaction::KernelFeatures::Plain { fee: 2000000 }
 		);
 
@@ -170,7 +175,7 @@ fn basic_transaction_api(test_dir: &'static str) -> Result<(), libwallet::Error>
 
 	// post transaction
 	wallet::controller::owner_single_use(Some(wallet1.clone()), mask1, None, |api, m| {
-		api.post_tx(m, &slate.tx, false)?;
+		api.post_tx(m, slate.tx_or_err()?, false)?;
 		Ok(())
 	})?;