add wallet unpack command (#433)

controller/src/command.rs

@@ -23,7 +23,7 @@ use crate::impls::SlateGetter as _;
 use crate::impls::{HttpSlateSender, PathToSlate, PathToSlatepack, SlatePutter};
 use crate::keychain;
 use crate::libwallet::{
-	self, InitTxArgs, IssueInvoiceTxArgs, NodeClient, PaymentProof, Slate, SlateVersion,
+	self, InitTxArgs, IssueInvoiceTxArgs, NodeClient, PaymentProof, Slate, SlateVersion, Slatepack,
 	SlatepackAddress, Slatepacker, SlatepackerArgs, WalletLCProvider,
 };
 use crate::util::secp::key::SecretKey;
@@ -603,7 +603,7 @@ where
 					});
 					let pts = PathToSlatepack::new(f.into(), &packer, true);
 					sl = Some(pts.get_tx()?.0);
-					ret_address = pts.get_slatepack()?.sender;
+					ret_address = pts.get_slatepack(true)?.sender;
 					Ok(())
 				})?;
 			}
@@ -626,7 +626,7 @@ where
 						|api, m| {
 							slate =
 								api.slate_from_slatepack_message(m, message.clone(), vec![0])?;
-							let slatepack = api.decode_slatepack_message(message)?;
+							let slatepack = api.decode_slatepack_message(message, true)?;
 							ret_address = slatepack.sender;
 							Ok(())
 						},
@@ -713,6 +713,84 @@ where
 	}
 }
 
+pub fn unpack<L, C, K>(
+	owner_api: &mut Owner<L, C, K>,
+	keychain_mask: Option<&SecretKey>,
+	args: ReceiveArgs,
+) -> Result<(), Error>
+where
+	L: WalletLCProvider<'static, C, K> + 'static,
+	C: NodeClient + 'static,
+	K: keychain::Keychain + 'static,
+{
+	let mut slatepack = match args.input_file {
+		Some(f) => {
+			let packer = Slatepacker::new(SlatepackerArgs {
+				sender: None,
+				recipients: vec![],
+				dec_key: None,
+			});
+			PathToSlatepack::new(f.into(), &packer, true).get_slatepack(false)?
+		}
+		None => match args.input_slatepack_message {
+			Some(mes) => {
+				let mut sp = Slatepack::default();
+				controller::owner_single_use(None, keychain_mask, Some(owner_api), |api, _| {
+					sp = api.decode_slatepack_message(mes, false)?;
+					Ok(())
+				})?;
+				sp
+			}
+			None => {
+				return Err(ErrorKind::ArgumentError("Invalid Slatepack Input".into()).into());
+			}
+		},
+	};
+	println!();
+	println!("SLATEPACK CONTENTS");
+	println!("------------------");
+	println!("{}", slatepack);
+	println!("------------------");
+
+	let packer = Slatepacker::new(SlatepackerArgs {
+		sender: None,
+		recipients: vec![],
+		dec_key: None,
+	});
+
+	if slatepack.mode == 1 {
+		controller::owner_single_use(None, keychain_mask, Some(owner_api), |api, m| {
+			let dec_key = api.get_slatepack_secret_key(m, 0)?;
+			match slatepack.try_decrypt_payload(Some(&dec_key)) {
+				Ok(_) => {
+					println!("Slatepack is encrypted for this wallet");
+					println!();
+					println!("DECRYPTED SLATEPACK");
+					println!("-------------------");
+					println!("{}", slatepack);
+					let slate = packer.get_slate(&slatepack)?;
+					println!();
+					println!("DECRYPTED SLATE");
+					println!("---------------");
+					println!("{}", slate);
+				}
+				Err(_) => {
+					println!("Slatepack payload cannot be decrypted by this wallet");
+				}
+			}
+			Ok(())
+		})?;
+	} else {
+		let slate = packer.get_slate(&slatepack)?;
+		println!("Slatepack is not encrypted");
+		println!();
+		println!("SLATE");
+		println!("-----");
+		println!("{}", slate);
+	}
+	Ok(())
+}
+
 /// Finalize command args
 #[derive(Clone)]
 pub struct FinalizeArgs {

controller/tests/slatepack.rs

@@ -72,7 +72,7 @@ fn slate_from_packed(
 	if armored {
 		file = format!("{}.armored", file);
 	}
-	let slatepack = PathToSlatepack::new(file.into(), &packer, armored).get_slatepack()?;
+	let slatepack = PathToSlatepack::new(file.into(), &packer, armored).get_slatepack(true)?;
 	Ok((slatepack.clone(), packer.get_slate(&slatepack)?))
 }
 
@@ -496,7 +496,7 @@ fn slatepack_api_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
 		let enc_addr = api.get_slatepack_address(m, 0)?;
 		let slatepack = api.create_slatepack_message(m, &slate, Some(0), vec![enc_addr])?;
 		println!("{}", slatepack);
-		let slatepack_raw = api.decode_slatepack_message(slatepack.clone())?;
+		let slatepack_raw = api.decode_slatepack_message(slatepack.clone(), true)?;
 		println!("{}", slatepack_raw);
 		let decoded_slate = api.slate_from_slatepack_message(m, slatepack, vec![0])?;
 		println!("{}", decoded_slate);