Payment Proof Implementation (#259)

* refactor address generation code into libwallet, bool to flag whether to include proof, add sender address in init_send_tx

* rustfmt

* require payment proof addr as part of init_tx

* rustfmt

* store payment proof on sender transaction side

* rustfmt

* change sig to ed25519 sig

* rustfmt

* add message creation and signature

* rustfmt

* add payment proof verification function

* rustfmt

* validate proof on sender side, store proof

* rustfmt

* fix json tests

* fixes and updates to tests

* added API functions for converting and retrieving proof addresses

* rustfmt

* add payment proof to init_send_tx example

* rustfmt

* incorrect comment

controller/tests/payment_proofs.rs

@@ -0,0 +1,153 @@
+// Copyright 2019 The Grin Developers
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! tests differing accounts in the same wallet
+#[macro_use]
+extern crate log;
+extern crate grin_wallet_controller as wallet;
+extern crate grin_wallet_impls as impls;
+extern crate grin_wallet_util;
+
+use grin_wallet_libwallet as libwallet;
+use impls::test_framework::{self, LocalWalletClient};
+use libwallet::{InitTxArgs, Slate};
+use std::thread;
+use std::time::Duration;
+
+#[macro_use]
+mod common;
+use common::{clean_output_dir, create_wallet_proxy, setup};
+
+/// Various tests on accounts within the same wallet
+fn payment_proofs_test_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
+	// Create a new proxy to simulate server and wallet responses
+	let mut wallet_proxy = create_wallet_proxy(test_dir);
+	let chain = wallet_proxy.chain.clone();
+
+	create_wallet_and_add!(
+		client1,
+		wallet1,
+		mask1_i,
+		test_dir,
+		"wallet1",
+		None,
+		&mut wallet_proxy,
+		false
+	);
+
+	let mask1 = (&mask1_i).as_ref();
+
+	create_wallet_and_add!(
+		client2,
+		wallet2,
+		mask2_i,
+		test_dir,
+		"wallet2",
+		None,
+		&mut wallet_proxy,
+		false
+	);
+
+	let mask2 = (&mask2_i).as_ref();
+
+	// Set the wallet proxy listener running
+	thread::spawn(move || {
+		if let Err(e) = wallet_proxy.run() {
+			error!("Wallet Proxy error: {}", e);
+		}
+	});
+
+	// few values to keep things shorter
+
+	// Do some mining
+	let bh = 10u64;
+	let _ =
+		test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, bh as usize, false);
+
+	let mut address = None;
+	wallet::controller::owner_single_use(wallet2.clone(), mask2, |api, m| {
+		address = Some(api.get_public_proof_address(m, 0)?);
+		Ok(())
+	})?;
+
+	let address = address.unwrap();
+	println!("Public address is: {:?}", address);
+	let amount = 60_000_000_000;
+	let mut slate = Slate::blank(1);
+	wallet::controller::owner_single_use(wallet1.clone(), mask1, |sender_api, m| {
+		// note this will increment the block count as part of the transaction "Posting"
+		let args = InitTxArgs {
+			src_acct_name: None,
+			amount: amount,
+			minimum_confirmations: 2,
+			max_outputs: 500,
+			num_change_outputs: 1,
+			selection_strategy_is_use_all: true,
+			payment_proof_recipient_address: Some(address),
+			..Default::default()
+		};
+		let slate_i = sender_api.init_send_tx(m, args)?;
+
+		assert_eq!(
+			slate_i.payment_proof.as_ref().unwrap().receiver_address,
+			address
+		);
+		println!(
+			"Sender addr: {:?}",
+			slate_i.payment_proof.as_ref().unwrap().sender_address
+		);
+
+		// Check we are creating a tx with the expected lock_height of 0.
+		// We will check this produces a Plain kernel later.
+		assert_eq!(0, slate.lock_height);
+
+		slate = client1.send_tx_slate_direct("wallet2", &slate_i)?;
+		sender_api.tx_lock_outputs(m, &slate, 0)?;
+
+		// Ensure what's stored in TX log for payment proof is correct
+		let (_, txs) = sender_api.retrieve_txs(m, true, None, Some(slate.id))?;
+		assert!(txs[0].payment_proof.is_some());
+		let pp = txs[0].clone().payment_proof.unwrap();
+		assert_eq!(
+			pp.receiver_address,
+			slate_i.payment_proof.as_ref().unwrap().receiver_address
+		);
+		assert!(pp.receiver_signature.is_some());
+		assert_eq!(pp.sender_address_path, 0);
+		assert_eq!(pp.sender_signature, None);
+
+		slate = sender_api.finalize_tx(m, &slate)?;
+
+		// Check payment proof here
+		let (_, txs) = sender_api.retrieve_txs(m, true, None, Some(slate.id))?;
+		let tx = txs[0].clone();
+
+		println!("{:?}", tx);
+
+		Ok(())
+	})?;
+
+	// let logging finish
+	thread::sleep(Duration::from_millis(200));
+	Ok(())
+}
+
+#[test]
+fn payment_proofs() {
+	let test_dir = "test_output/payment_proofs";
+	setup(test_dir);
+	if let Err(e) = payment_proofs_test_impl(test_dir) {
+		panic!("Libwallet Error: {} - {}", e, e.backtrace().unwrap());
+	}
+	clean_output_dir(test_dir);
+}

controller/tests/updater_thread.rs

@@ -19,13 +19,10 @@ extern crate grin_wallet_controller as wallet;
 extern crate grin_wallet_impls as impls;
 extern crate grin_wallet_libwallet as libwallet;
 
-use crate::libwallet::api_impl::owner_updater::{start_updater_log_thread, StatusMessage};
-use grin_wallet_util::grin_core as core;
+// use crate::libwallet::api_impl::owner_updater::{start_updater_log_thread, StatusMessage};
+// use grin_wallet_util::grin_core as core;
 
-use self::libwallet::{InitTxArgs, Slate};
 use impls::test_framework::{self, LocalWalletClient};
-use impls::{PathToSlate, SlateGetter as _, SlatePutter as _};
-use std::sync::mpsc::channel;
 use std::thread;
 use std::time::Duration;
 
@@ -71,9 +68,6 @@ fn updater_thread_test_impl(test_dir: &'static str) -> Result<(), libwallet::Err
 		}
 	});
 
-	// few values to keep things shorter
-	let reward = core::consensus::REWARD;
-
 	// add some accounts
 	wallet::controller::owner_single_use(wallet1.clone(), mask1, |api, m| {
 		api.create_account_path(m, "mining")?;
@@ -93,7 +87,7 @@ fn updater_thread_test_impl(test_dir: &'static str) -> Result<(), libwallet::Err
 		wallet_inst!(wallet1, w);
 		w.set_parent_key_id_by_name("mining")?;
 	}
-	let mut bh = 10u64;
+	let bh = 10u64;
 	let _ =
 		test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, bh as usize, false);