TTL Implementation (#261)

* 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 * add commands for requesting payment proofs * rustfmt * wire up payment proofs into command line * rustfmt * add address command * rustfmt * added tor sending from owner api * rustfmt * add TTL to slate, transaction log * ttl cutoff tests * add ttl check to recieve functions, add tests, modify doctests * rustfmt * fixes from upstream changes and test fixes * rustfmt * remove unnecessary block header version check
2026-11-15 03:53:52 +01:00 · 2019-12-02 13:54:57 +00:00
parent 9fd1d49dda
commit 45480392da
25 changed files with 653 additions and 327 deletions
@@ -58,14 +58,14 @@ fn check_middleware(
 		// allow coinbases to be built regardless
 		ForeignCheckMiddlewareFn::BuildCoinbase => Ok(()),
 		_ => {
-			let mut bhv = 1;
+			let mut bhv = 2;
 			if let Some(n) = node_version_info {
 				bhv = n.block_header_version;
 			}
 			if let Some(s) = slate {
 				if s.version_info.version < CURRENT_SLATE_VERSION
-					|| (bhv == 1 && s.version_info.block_header_version != 1)
-					|| (bhv > 1 && s.version_info.block_header_version < GRIN_BLOCK_HEADER_VERSION)
+//					|| (bhv == 3 && s.version_info.block_header_version != 3)
+					|| (bhv > 3 && s.version_info.block_header_version < GRIN_BLOCK_HEADER_VERSION)
 				{
 					Err(ErrorKind::Compatibility(
 						"Incoming Slate is not compatible with this wallet. \
@@ -152,6 +152,7 @@ pub fn txs(
 		bMG->"Type",
 		bMG->"Shared Transaction Id",
 		bMG->"Creation Time",
+		bMG->"TTL Cutoff Height",
 		bMG->"Confirmed?",
 		bMG->"Confirmation Time",
 		bMG->"Num. \nInputs",
@@ -173,6 +174,10 @@ pub fn txs(
 		};
 		let entry_type = format!("{}", t.tx_type);
 		let creation_ts = format!("{}", t.creation_ts.format("%Y-%m-%d %H:%M:%S"));
+		let ttl_cutoff_height = match t.ttl_cutoff_height {
+			Some(b) => format!("{}", b),
+			None => "None".to_owned(),
+		};
 		let confirmation_ts = match t.confirmation_ts {
 			Some(m) => format!("{}", m.format("%Y-%m-%d %H:%M:%S")),
 			None => "None".to_owned(),
@@ -212,6 +217,7 @@ pub fn txs(
 				bFC->entry_type,
 				bFC->slate_id,
 				bFB->creation_ts,
+				bFB->ttl_cutoff_height,
 				bFC->confirmed,
 				bFB->confirmation_ts,
 				bFC->num_inputs,
@@ -0,0 +1,182 @@
+// 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 ttl_cutoff blocks
+#[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, TxLogEntryType};
+use std::thread;
+use std::time::Duration;
+
+#[macro_use]
+mod common;
+use common::{clean_output_dir, create_wallet_proxy, setup};
+
+/// Test cutoff block times
+fn ttl_cutoff_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 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,
+			ttl_blocks: Some(2),
+			..Default::default()
+		};
+		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)?;
+
+		let (_, txs) = sender_api.retrieve_txs(m, true, None, Some(slate.id))?;
+		let tx = txs[0].clone();
+
+		assert_eq!(tx.ttl_cutoff_height, Some(12));
+		Ok(())
+	})?;
+
+	// Now mine past the block, and check again. Transaction should be gone.
+	let _ = test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, 2, false);
+
+	wallet::controller::owner_single_use(wallet1.clone(), mask1, |sender_api, m| {
+		let (_, txs) = sender_api.retrieve_txs(m, true, None, Some(slate.id))?;
+		let tx = txs[0].clone();
+
+		assert_eq!(tx.ttl_cutoff_height, Some(12));
+		assert!(tx.tx_type == TxLogEntryType::TxSentCancelled);
+		Ok(())
+	})?;
+
+	// Should also be gone in wallet 2, and output gone
+	wallet::controller::owner_single_use(wallet2.clone(), mask2, |sender_api, m| {
+		let (_, txs) = sender_api.retrieve_txs(m, true, None, Some(slate.id))?;
+		let tx = txs[0].clone();
+		let outputs = sender_api.retrieve_outputs(m, false, true, None)?.1;
+		assert_eq!(outputs.len(), 0);
+
+		assert_eq!(tx.ttl_cutoff_height, Some(12));
+		assert!(tx.tx_type == TxLogEntryType::TxReceivedCancelled);
+		Ok(())
+	})?;
+
+	// try again, except try and send off the transaction for completion beyond the expiry
+	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,
+			ttl_blocks: Some(2),
+			..Default::default()
+		};
+		let slate_i = sender_api.init_send_tx(m, args)?;
+		sender_api.tx_lock_outputs(m, &slate_i, 0)?;
+		slate = slate_i;
+
+		let (_, txs) = sender_api.retrieve_txs(m, true, None, Some(slate.id))?;
+		let tx = txs[0].clone();
+
+		assert_eq!(tx.ttl_cutoff_height, Some(14));
+		Ok(())
+	})?;
+
+	// Mine past the ttl block and try to send
+	let _ = test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, 2, false);
+
+	// Wallet 2 will need to have updated past the TTL
+	wallet::controller::owner_single_use(wallet2.clone(), mask2, |sender_api, m| {
+		let (_, _) = sender_api.retrieve_txs(m, true, None, Some(slate.id))?;
+		Ok(())
+	})?;
+
+	// And when wallet 1 sends, should be rejected
+	wallet::controller::owner_single_use(wallet1.clone(), mask1, |_sender_api, _m| {
+		let res = client1.send_tx_slate_direct("wallet2", &slate);
+		println!("Send after TTL result is: {:?}", res);
+		assert!(res.is_err());
+		Ok(())
+	})?;
+
+	// let logging finish
+	thread::sleep(Duration::from_millis(200));
+	Ok(())
+}
+
+#[test]
+fn ttl_cutoff() {
+	let test_dir = "test_output/ttl_cutoff";
+	setup(test_dir);
+	if let Err(e) = ttl_cutoff_test_impl(test_dir) {
+		panic!("Libwallet Error: {} - {}", e, e.backtrace().unwrap());
+	}
+	clean_output_dir(test_dir);
+}