Update transactions via kernel where necessary (mimblewimble#220)

* add test for no change output scenario

* rustfmt

* add kernel lookup functionality to transaction retrievals

* rustfmt

* updates and fixes for no-change invoice workflow, test implementations

* rustfmt

api/src/owner_rpc.rs

@@ -232,6 +232,8 @@ pub trait OwnerRpc: Sync + Send {
 			  "creation_ts": "2019-01-15T16:01:26Z",
 			  "fee": null,
 			  "id": 0,
+			  "kernel_excess": null,
+			  "kernel_lookup_min_height": null,
 			  "messages": null,
 			  "num_inputs": 0,
 			  "num_outputs": 1,
@@ -248,6 +250,8 @@ pub trait OwnerRpc: Sync + Send {
 			  "creation_ts": "2019-01-15T16:01:26Z",
 			  "fee": null,
 			  "id": 1,
+			  "kernel_excess": null,
+			  "kernel_lookup_min_height": null,
 			  "messages": null,
 			  "num_inputs": 0,
 			  "num_outputs": 1,

api/src/owner_rpc_s.rs

@@ -255,6 +255,8 @@ pub trait OwnerRpcS {
 			  "creation_ts": "2019-01-15T16:01:26Z",
 			  "fee": null,
 			  "id": 0,
+			  "kernel_excess": null,
+			  "kernel_lookup_min_height": null,
 			  "messages": null,
 			  "num_inputs": 0,
 			  "num_outputs": 1,
@@ -271,6 +273,8 @@ pub trait OwnerRpcS {
 			  "creation_ts": "2019-01-15T16:01:26Z",
 			  "fee": null,
 			  "id": 1,
+			  "kernel_excess": null,
+			  "kernel_lookup_min_height": null,
 			  "messages": null,
 			  "num_inputs": 0,
 			  "num_outputs": 1,

controller/tests/no_change.rs

@@ -0,0 +1,168 @@
+// Copyright 2018 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.
+
+//! Test sender transaction with no change output
+#[macro_use]
+extern crate log;
+extern crate grin_wallet_controller as wallet;
+extern crate grin_wallet_impls as impls;
+
+use grin_wallet_util::grin_core as core;
+
+use grin_wallet_libwallet as libwallet;
+use impls::test_framework::{self, LocalWalletClient};
+use libwallet::{InitTxArgs, IssueInvoiceTxArgs, Slate};
+use std::thread;
+use std::time::Duration;
+
+#[macro_use]
+mod common;
+use common::{clean_output_dir, create_wallet_proxy, setup};
+
+fn no_change_test_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
+	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
+	let reward = core::consensus::REWARD;
+
+	// Mine into wallet 1
+	let _ = test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, 4, false);
+	let fee = core::libtx::tx_fee(1, 1, 1, None);
+
+	// send a single block's worth of transactions with minimal strategy
+	let mut slate = Slate::blank(2);
+	wallet::controller::owner_single_use(wallet1.clone(), mask1, |api, m| {
+		let args = InitTxArgs {
+			src_acct_name: None,
+			amount: reward - fee,
+			minimum_confirmations: 2,
+			max_outputs: 500,
+			num_change_outputs: 1,
+			selection_strategy_is_use_all: false,
+			..Default::default()
+		};
+		slate = api.init_send_tx(m, args)?;
+		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)?;
+		Ok(())
+	})?;
+
+	// Refresh and check transaction log for wallet 1
+	wallet::controller::owner_single_use(wallet1.clone(), mask2, |api, m| {
+		let (refreshed, txs) = api.retrieve_txs(m, true, None, Some(slate.id))?;
+		assert!(refreshed);
+		let tx = txs[0].clone();
+		println!("{:?}", tx);
+		assert!(tx.confirmed);
+		Ok(())
+	})?;
+
+	// ensure invoice TX works as well with no change
+	wallet::controller::owner_single_use(wallet2.clone(), mask2, |api, m| {
+		// Wallet 2 inititates an invoice transaction, requesting payment
+		let args = IssueInvoiceTxArgs {
+			amount: reward - fee,
+			..Default::default()
+		};
+		slate = api.issue_invoice_tx(m, args)?;
+		Ok(())
+	})?;
+
+	wallet::controller::owner_single_use(wallet1.clone(), mask1, |api, m| {
+		// Wallet 1 receives the invoice transaction
+		let args = InitTxArgs {
+			src_acct_name: None,
+			amount: slate.amount,
+			minimum_confirmations: 2,
+			max_outputs: 500,
+			num_change_outputs: 1,
+			selection_strategy_is_use_all: false,
+			..Default::default()
+		};
+		slate = api.process_invoice_tx(m, &slate, args)?;
+		api.tx_lock_outputs(m, &slate, 0)?;
+		Ok(())
+	})?;
+
+	// wallet 2 finalizes and posts
+	wallet::controller::foreign_single_use(wallet2.clone(), mask2_i.clone(), |api| {
+		// Wallet 2 receives the invoice transaction
+		slate = api.finalize_invoice_tx(&slate)?;
+		Ok(())
+	})?;
+	wallet::controller::owner_single_use(wallet2.clone(), mask1, |api, m| {
+		api.post_tx(m, &slate.tx, false)?;
+		Ok(())
+	})?;
+
+	// Refresh and check transaction log for wallet 1
+	wallet::controller::owner_single_use(wallet1.clone(), mask2, |api, m| {
+		let (refreshed, txs) = api.retrieve_txs(m, true, None, Some(slate.id))?;
+		assert!(refreshed);
+		for tx in txs {
+			println!("{:?}", tx);
+			assert!(tx.confirmed);
+		}
+		Ok(())
+	})?;
+
+	// let logging finish
+	thread::sleep(Duration::from_millis(200));
+	Ok(())
+}
+
+#[test]
+fn no_change() {
+	let test_dir = "test_output/no_change";
+	setup(test_dir);
+	if let Err(e) = no_change_test_impl(test_dir) {
+		panic!("Libwallet Error: {} - {}", e, e.backtrace().unwrap());
+	}
+	clean_output_dir(test_dir);
+}

impls/Cargo.toml

@@ -15,6 +15,7 @@ failure = "0.1"
 failure_derive = "0.1"
 futures = "0.1"
 rand = "0.5"
+semver = "0.9"
 serde = "1"
 serde_derive = "1"
 serde_json = "1"

impls/src/node_clients/http.rs

@@ -17,14 +17,17 @@
 
 use futures::{stream, Stream};
 
+use crate::api::LocatedTxKernel;
+use crate::core::core::TxKernel;
 use crate::libwallet::{NodeClient, NodeVersionInfo, TxWrapper};
+use semver::Version;
 use std::collections::HashMap;
 use tokio::runtime::Runtime;
 
 use crate::api;
 use crate::libwallet;
-use crate::util;
 use crate::util::secp::pedersen;
+use crate::util::{self, to_hex};
 
 #[derive(Clone)]
 pub struct HTTPNodeClient {
@@ -127,6 +130,55 @@ impl NodeClient for HTTPNodeClient {
 		}
 	}
 
+	/// Get kernel implementation
+	fn get_kernel(
+		&mut self,
+		excess: &pedersen::Commitment,
+		min_height: Option<u64>,
+		max_height: Option<u64>,
+	) -> Result<Option<(TxKernel, u64, u64)>, libwallet::Error> {
+		let version = self
+			.get_version_info()
+			.ok_or(libwallet::ErrorKind::ClientCallback(
+				"Unable to get version".into(),
+			))?;
+		let version = Version::parse(&version.node_version)
+			.map_err(|_| libwallet::ErrorKind::ClientCallback("Unable to parse version".into()))?;
+		if version <= Version::new(2, 0, 0) {
+			return Err(libwallet::ErrorKind::ClientCallback(
+				"Kernel lookup not supported by node, please upgrade it".into(),
+			)
+			.into());
+		}
+
+		let mut query = String::new();
+		if let Some(h) = min_height {
+			query += &format!("min_height={}", h);
+		}
+		if let Some(h) = max_height {
+			if query.len() > 0 {
+				query += "&";
+			}
+			query += &format!("max_height={}", h);
+		}
+		if query.len() > 0 {
+			query.insert_str(0, "?");
+		}
+
+		let url = format!(
+			"{}/v1/chain/kernels/{}{}",
+			self.node_url(),
+			to_hex(excess.0.to_vec()),
+			query
+		);
+		let res: Option<LocatedTxKernel> = api::client::get(url.as_str(), self.node_api_secret())
+			.map_err(|e| {
+			libwallet::ErrorKind::ClientCallback(format!("Kernel lookup: {}", e))
+		})?;
+
+		Ok(res.map(|k| (k.tx_kernel, k.height, k.mmr_index)))
+	}
+
 	/// Retrieve outputs from node
 	fn get_outputs_from_node(
 		&self,

impls/src/test_framework/mod.rs

@@ -52,6 +52,23 @@ fn get_output_local(chain: &chain::Chain, commit: &pedersen::Commitment) -> Opti
 	None
 }
 
+/// Get a kernel from the chain locally
+fn get_kernel_local(
+	chain: Arc<chain::Chain>,
+	excess: &pedersen::Commitment,
+	min_height: Option<u64>,
+	max_height: Option<u64>,
+) -> Option<api::LocatedTxKernel> {
+	chain
+		.get_kernel_height(&excess, min_height, max_height)
+		.unwrap()
+		.map(|(tx_kernel, height, mmr_index)| api::LocatedTxKernel {
+			tx_kernel,
+			height,
+			mmr_index,
+		})
+}
+
 /// get output listing traversing pmmr from local
 fn get_outputs_by_pmmr_index_local(
 	chain: Arc<chain::Chain>,