From: Matt Corallo <649246+TheBlueMatt@users.noreply.github.com>
Date: Tue, 4 May 2021 01:44:18 +0000 (+0000)
Subject: Merge pull request #845 from ariard/2021-03-hardcode-dust
X-Git-Tag: v0.0.14~2
X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;ds=sidebyside;h=58e4ce251e202cacadb82341ed16d299057fc646;hp=-c;p=rust-lightning

Merge pull request #845 from ariard/2021-03-hardcode-dust

Switch to a max counterparty's `dust_limit_satoshis` constant
---

58e4ce251e202cacadb82341ed16d299057fc646
diff --combined fuzz/src/chanmon_consistency.rs
index b48604dba,45b10ca56..3fd6515fd
--- a/fuzz/src/chanmon_consistency.rs
+++ b/fuzz/src/chanmon_consistency.rs
@@@ -37,8 -37,7 +37,8 @@@ use lightning::chain::channelmonitor::{
  use lightning::chain::transaction::OutPoint;
  use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator};
  use lightning::chain::keysinterface::{KeysInterface, InMemorySigner};
 -use lightning::ln::channelmanager::{BestBlock, ChainParameters, ChannelManager, PaymentHash, PaymentPreimage, PaymentSecret, PaymentSendFailure, ChannelManagerReadArgs};
 +use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 +use lightning::ln::channelmanager::{BestBlock, ChainParameters, ChannelManager, PaymentSendFailure, ChannelManagerReadArgs};
  use lightning::ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
  use lightning::ln::msgs::{CommitmentUpdate, ChannelMessageHandler, DecodeError, ErrorAction, UpdateAddHTLC, Init};
  use lightning::util::enforcing_trait_impls::{EnforcingSigner, INITIAL_REVOKED_COMMITMENT_NUMBER};
@@@ -56,7 -55,6 +56,7 @@@ use utils::test_logger
  use utils::test_persister::TestPersister;
  
  use bitcoin::secp256k1::key::{PublicKey,SecretKey};
 +use bitcoin::secp256k1::recovery::RecoverableSignature;
  use bitcoin::secp256k1::Secp256k1;
  
  use std::mem;
@@@ -207,10 -205,6 +207,10 @@@ impl KeysInterface for KeyProvider 
  			disable_revocation_policy_check: false,
  		})
  	}
 +
 +	fn sign_invoice(&self, _invoice_preimage: Vec<u8>) -> Result<RecoverableSignature, ()> {
 +		unreachable!()
 +	}
  }
  
  impl KeyProvider {
@@@ -267,58 -261,45 +267,58 @@@ fn check_payment_err(send_err: PaymentS
  
  type ChanMan = ChannelManager<EnforcingSigner, Arc<TestChainMonitor>, Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>, Arc<dyn Logger>>;
  
 +#[inline]
 +fn get_payment_secret_hash(dest: &ChanMan, payment_id: &mut u8) -> Option<(PaymentSecret, PaymentHash)> {
 +	let mut payment_hash;
 +	for _ in 0..256 {
 +		payment_hash = PaymentHash(Sha256::hash(&[*payment_id; 1]).into_inner());
 +		if let Ok(payment_secret) = dest.create_inbound_payment_for_hash(payment_hash, None, 7200, 0) {
 +			return Some((payment_secret, payment_hash));
 +		}
 +		*payment_id = payment_id.wrapping_add(1);
 +	}
 +	None
 +}
 +
  #[inline]
  fn send_payment(source: &ChanMan, dest: &ChanMan, dest_chan_id: u64, amt: u64, payment_id: &mut u8) -> bool {
 -	let payment_hash = Sha256::hash(&[*payment_id; 1]);
 -	*payment_id = payment_id.wrapping_add(1);
 +	let (payment_secret, payment_hash) =
 +		if let Some((secret, hash)) = get_payment_secret_hash(dest, payment_id) { (secret, hash) } else { return true; };
  	if let Err(err) = source.send_payment(&Route {
  		paths: vec![vec![RouteHop {
  			pubkey: dest.get_our_node_id(),
 -			node_features: NodeFeatures::empty(),
 +			node_features: NodeFeatures::known(),
  			short_channel_id: dest_chan_id,
 -			channel_features: ChannelFeatures::empty(),
 +			channel_features: ChannelFeatures::known(),
  			fee_msat: amt,
  			cltv_expiry_delta: 200,
  		}]],
 -	}, PaymentHash(payment_hash.into_inner()), &None) {
 +	}, payment_hash, &Some(payment_secret)) {
  		check_payment_err(err);
  		false
  	} else { true }
  }
  #[inline]
  fn send_hop_payment(source: &ChanMan, middle: &ChanMan, middle_chan_id: u64, dest: &ChanMan, dest_chan_id: u64, amt: u64, payment_id: &mut u8) -> bool {
 -	let payment_hash = Sha256::hash(&[*payment_id; 1]);
 -	*payment_id = payment_id.wrapping_add(1);
 +	let (payment_secret, payment_hash) =
 +		if let Some((secret, hash)) = get_payment_secret_hash(dest, payment_id) { (secret, hash) } else { return true; };
  	if let Err(err) = source.send_payment(&Route {
  		paths: vec![vec![RouteHop {
  			pubkey: middle.get_our_node_id(),
 -			node_features: NodeFeatures::empty(),
 +			node_features: NodeFeatures::known(),
  			short_channel_id: middle_chan_id,
 -			channel_features: ChannelFeatures::empty(),
 +			channel_features: ChannelFeatures::known(),
  			fee_msat: 50000,
  			cltv_expiry_delta: 100,
  		},RouteHop {
  			pubkey: dest.get_our_node_id(),
 -			node_features: NodeFeatures::empty(),
 +			node_features: NodeFeatures::known(),
  			short_channel_id: dest_chan_id,
 -			channel_features: ChannelFeatures::empty(),
 +			channel_features: ChannelFeatures::known(),
  			fee_msat: amt,
  			cltv_expiry_delta: 200,
  		}]],
 -	}, PaymentHash(payment_hash.into_inner()), &None) {
 +	}, payment_hash, &Some(payment_secret)) {
  		check_payment_err(err);
  		false
  	} else { true }
@@@ -338,7 -319,6 +338,6 @@@ pub fn do_test<Out: test_logger::Output
  			let mut config = UserConfig::default();
  			config.channel_options.fee_proportional_millionths = 0;
  			config.channel_options.announced_channel = true;
- 			config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
  			let network = Network::Bitcoin;
  			let params = ChainParameters {
  				network,
@@@ -358,7 -338,6 +357,6 @@@
  			let mut config = UserConfig::default();
  			config.channel_options.fee_proportional_millionths = 0;
  			config.channel_options.announced_channel = true;
- 			config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
  
  			let mut monitors = HashMap::new();
  			let mut old_monitors = $old_monitors.latest_monitors.lock().unwrap();
@@@ -542,6 -521,48 +540,6 @@@
  	}
  
  	loop {
 -		macro_rules! send_payment_with_secret {
 -			($source: expr, $middle: expr, $dest: expr) => { {
 -				let payment_hash = Sha256::hash(&[payment_id; 1]);
 -				payment_id = payment_id.wrapping_add(1);
 -				let payment_secret = Sha256::hash(&[payment_id; 1]);
 -				payment_id = payment_id.wrapping_add(1);
 -				if let Err(err) = $source.send_payment(&Route {
 -					paths: vec![vec![RouteHop {
 -						pubkey: $middle.0.get_our_node_id(),
 -						node_features: NodeFeatures::empty(),
 -						short_channel_id: $middle.1,
 -						channel_features: ChannelFeatures::empty(),
 -						fee_msat: 50_000,
 -						cltv_expiry_delta: 100,
 -					},RouteHop {
 -						pubkey: $dest.0.get_our_node_id(),
 -						node_features: NodeFeatures::empty(),
 -						short_channel_id: $dest.1,
 -						channel_features: ChannelFeatures::empty(),
 -						fee_msat: 10_000_000,
 -						cltv_expiry_delta: 200,
 -					}],vec![RouteHop {
 -						pubkey: $middle.0.get_our_node_id(),
 -						node_features: NodeFeatures::empty(),
 -						short_channel_id: $middle.1,
 -						channel_features: ChannelFeatures::empty(),
 -						fee_msat: 50_000,
 -						cltv_expiry_delta: 100,
 -					},RouteHop {
 -						pubkey: $dest.0.get_our_node_id(),
 -						node_features: NodeFeatures::empty(),
 -						short_channel_id: $dest.1,
 -						channel_features: ChannelFeatures::empty(),
 -						fee_msat: 10_000_000,
 -						cltv_expiry_delta: 200,
 -					}]],
 -				}, PaymentHash(payment_hash.into_inner()), &Some(PaymentSecret(payment_secret.into_inner()))) {
 -					check_payment_err(err);
 -				}
 -			} }
 -		}
 -
  		macro_rules! process_msg_events {
  			($node: expr, $corrupt_forward: expr) => { {
  				let events = if $node == 1 {
@@@ -693,12 -714,12 +691,12 @@@
  				let had_events = !events.is_empty();
  				for event in events.drain(..) {
  					match event {
 -						events::Event::PaymentReceived { payment_hash, payment_secret, amt } => {
 +						events::Event::PaymentReceived { payment_hash, .. } => {
  							if claim_set.insert(payment_hash.0) {
  								if $fail {
 -									assert!(nodes[$node].fail_htlc_backwards(&payment_hash, &payment_secret));
 +									assert!(nodes[$node].fail_htlc_backwards(&payment_hash));
  								} else {
 -									assert!(nodes[$node].claim_funds(PaymentPreimage(payment_hash.0), &payment_secret, amt));
 +									assert!(nodes[$node].claim_funds(PaymentPreimage(payment_hash.0)));
  								}
  							}
  						},
@@@ -765,15 -786,15 +763,15 @@@
  			},
  			0x0e => {
  				if chan_a_disconnected {
 -					nodes[0].peer_connected(&nodes[1].get_our_node_id(), &Init { features: InitFeatures::empty() });
 -					nodes[1].peer_connected(&nodes[0].get_our_node_id(), &Init { features: InitFeatures::empty() });
 +					nodes[0].peer_connected(&nodes[1].get_our_node_id(), &Init { features: InitFeatures::known() });
 +					nodes[1].peer_connected(&nodes[0].get_our_node_id(), &Init { features: InitFeatures::known() });
  					chan_a_disconnected = false;
  				}
  			},
  			0x0f => {
  				if chan_b_disconnected {
 -					nodes[1].peer_connected(&nodes[2].get_our_node_id(), &Init { features: InitFeatures::empty() });
 -					nodes[2].peer_connected(&nodes[1].get_our_node_id(), &Init { features: InitFeatures::empty() });
 +					nodes[1].peer_connected(&nodes[2].get_our_node_id(), &Init { features: InitFeatures::known() });
 +					nodes[2].peer_connected(&nodes[1].get_our_node_id(), &Init { features: InitFeatures::known() });
  					chan_b_disconnected = false;
  				}
  			},
@@@ -837,6 -858,9 +835,6 @@@
  			0x24 => { send_hop_payment(&nodes[0], &nodes[1], chan_a, &nodes[2], chan_b, 10_000_000, &mut payment_id); },
  			0x25 => { send_hop_payment(&nodes[2], &nodes[1], chan_b, &nodes[0], chan_a, 10_000_000, &mut payment_id); },
  
 -			0x26 => { send_payment_with_secret!(nodes[0], (&nodes[1], chan_a), (&nodes[2], chan_b)); },
 -			0x27 => { send_payment_with_secret!(nodes[2], (&nodes[1], chan_b), (&nodes[0], chan_a)); },
 -
  			0x28 => { send_payment(&nodes[0], &nodes[1], chan_a, 1_000_000, &mut payment_id); },
  			0x29 => { send_payment(&nodes[1], &nodes[0], chan_a, 1_000_000, &mut payment_id); },
  			0x2a => { send_payment(&nodes[1], &nodes[2], chan_b, 1_000_000, &mut payment_id); },
@@@ -910,13 -934,13 +908,13 @@@
  
  				// Next, make sure peers are all connected to each other
  				if chan_a_disconnected {
 -					nodes[0].peer_connected(&nodes[1].get_our_node_id(), &Init { features: InitFeatures::empty() });
 -					nodes[1].peer_connected(&nodes[0].get_our_node_id(), &Init { features: InitFeatures::empty() });
 +					nodes[0].peer_connected(&nodes[1].get_our_node_id(), &Init { features: InitFeatures::known() });
 +					nodes[1].peer_connected(&nodes[0].get_our_node_id(), &Init { features: InitFeatures::known() });
  					chan_a_disconnected = false;
  				}
  				if chan_b_disconnected {
 -					nodes[1].peer_connected(&nodes[2].get_our_node_id(), &Init { features: InitFeatures::empty() });
 -					nodes[2].peer_connected(&nodes[1].get_our_node_id(), &Init { features: InitFeatures::empty() });
 +					nodes[1].peer_connected(&nodes[2].get_our_node_id(), &Init { features: InitFeatures::known() });
 +					nodes[2].peer_connected(&nodes[1].get_our_node_id(), &Init { features: InitFeatures::known() });
  					chan_b_disconnected = false;
  				}
  
diff --combined fuzz/src/full_stack.rs
index 55fae3a85,d78443cbf..6abd84c68
--- a/fuzz/src/full_stack.rs
+++ b/fuzz/src/full_stack.rs
@@@ -32,8 -32,7 +32,8 @@@ use lightning::chain::chaininterface::{
  use lightning::chain::chainmonitor;
  use lightning::chain::transaction::OutPoint;
  use lightning::chain::keysinterface::{InMemorySigner, KeysInterface};
 -use lightning::ln::channelmanager::{BestBlock, ChainParameters, ChannelManager, PaymentHash, PaymentPreimage, PaymentSecret};
 +use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 +use lightning::ln::channelmanager::{BestBlock, ChainParameters, ChannelManager};
  use lightning::ln::peer_handler::{MessageHandler,PeerManager,SocketDescriptor};
  use lightning::ln::msgs::DecodeError;
  use lightning::routing::router::get_route;
@@@ -48,7 -47,6 +48,7 @@@ use utils::test_logger
  use utils::test_persister::TestPersister;
  
  use bitcoin::secp256k1::key::{PublicKey,SecretKey};
 +use bitcoin::secp256k1::recovery::RecoverableSignature;
  use bitcoin::secp256k1::Secp256k1;
  
  use std::cell::RefCell;
@@@ -314,10 -312,6 +314,10 @@@ impl KeysInterface for KeyProvider 
  	fn read_chan_signer(&self, data: &[u8]) -> Result<EnforcingSigner, DecodeError> {
  		EnforcingSigner::read(&mut std::io::Cursor::new(data))
  	}
 +
 +	fn sign_invoice(&self, _invoice_preimage: Vec<u8>) -> Result<RecoverableSignature, ()> {
 +		unreachable!()
 +	}
  }
  
  #[inline]
@@@ -360,7 -354,6 +360,6 @@@ pub fn do_test(data: &[u8], logger: &Ar
  	let mut config = UserConfig::default();
  	config.channel_options.fee_proportional_millionths =  slice_to_be32(get_slice!(4));
  	config.channel_options.announced_channel = get_slice!(1)[0] != 0;
- 	config.peer_channel_config_limits.min_dust_limit_satoshis = 0;
  	let network = Network::Bitcoin;
  	let params = ChainParameters {
  		network,
@@@ -377,7 -370,7 +376,7 @@@
  	}, our_network_key, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0], Arc::clone(&logger)));
  
  	let mut should_forward = false;
 -	let mut payments_received: Vec<(PaymentHash, Option<PaymentSecret>, u64)> = Vec::new();
 +	let mut payments_received: Vec<PaymentHash> = Vec::new();
  	let mut payments_sent = 0;
  	let mut pending_funding_generation: Vec<([u8; 32], u64, Script)> = Vec::new();
  	let mut pending_funding_signatures = HashMap::new();
@@@ -482,32 -475,23 +481,32 @@@
  				}
  			},
  			8 => {
 -				for (payment, payment_secret, amt) in payments_received.drain(..) {
 +				for payment in payments_received.drain(..) {
  					// SHA256 is defined as XOR of all input bytes placed in the first byte, and 0s
  					// for the remaining bytes. Thus, if not all remaining bytes are 0s we cannot
  					// fulfill this HTLC, but if they are, we can just take the first byte and
  					// place that anywhere in our preimage.
  					if &payment.0[1..] != &[0; 31] {
 -						channelmanager.fail_htlc_backwards(&payment, &payment_secret);
 +						channelmanager.fail_htlc_backwards(&payment);
  					} else {
  						let mut payment_preimage = PaymentPreimage([0; 32]);
  						payment_preimage.0[0] = payment.0[0];
 -						channelmanager.claim_funds(payment_preimage, &payment_secret, amt);
 +						channelmanager.claim_funds(payment_preimage);
  					}
  				}
  			},
 +			16 => {
 +				let payment_preimage = PaymentPreimage(keys_manager.get_secure_random_bytes());
 +				let mut sha = Sha256::engine();
 +				sha.input(&payment_preimage.0[..]);
 +				let payment_hash = PaymentHash(Sha256::from_engine(sha).into_inner());
 +				// Note that this may fail - our hashes may collide and we'll end up trying to
 +				// double-register the same payment_hash.
 +				let _ = channelmanager.create_inbound_payment_for_hash(payment_hash, None, 1, 0);
 +			},
  			9 => {
 -				for (payment, payment_secret, _) in payments_received.drain(..) {
 -					channelmanager.fail_htlc_backwards(&payment, &payment_secret);
 +				for payment in payments_received.drain(..) {
 +					channelmanager.fail_htlc_backwards(&payment);
  				}
  			},
  			10 => {
@@@ -586,9 -570,9 +585,9 @@@
  				Event::FundingGenerationReady { temporary_channel_id, channel_value_satoshis, output_script, .. } => {
  					pending_funding_generation.push((temporary_channel_id, channel_value_satoshis, output_script));
  				},
 -				Event::PaymentReceived { payment_hash, payment_secret, amt } => {
 +				Event::PaymentReceived { payment_hash, .. } => {
  					//TODO: enhance by fetching random amounts from fuzz input?
 -					payments_received.push((payment_hash, payment_secret, amt));
 +					payments_received.push(payment_hash);
  				},
  				Event::PaymentSent {..} => {},
  				Event::PaymentFailed {..} => {},
@@@ -665,7 -649,7 +664,7 @@@ mod tests 
  		// 030012 - inbound read from peer id 0 of len 18
  		// 0141 03000000000000000000000000000000 - message header indicating message length 321
  		// 0300fe - inbound read from peer id 0 of len 254
- 		// 0020 7500000000000000000000000000000000000000000000000000000000000000 ff4f00f805273c1b203bb5ebf8436bfde57b3be8c2f5e95d9491dbb181909679 000000000000c350 0000000000000000 0000000000000222 ffffffffffffffff 0000000000000222 0000000000000000 000000fd 0006 01e3 030000000000000000000000000000000000000000000000000000000000000001 030000000000000000000000000000000000000000000000000000000000000002 030000000000000000000000000000000000000000000000000000000000000003 030000000000000000000000000000000000000000000000000000000000000004 - beginning of open_channel message
+ 		// 0020 7500000000000000000000000000000000000000000000000000000000000000 ff4f00f805273c1b203bb5ebf8436bfde57b3be8c2f5e95d9491dbb181909679 000000000000c350 0000000000000000 000000000000014a ffffffffffffffff 0000000000000222 0000000000000000 000000fd 0006 01e3 030000000000000000000000000000000000000000000000000000000000000001 030000000000000000000000000000000000000000000000000000000000000002 030000000000000000000000000000000000000000000000000000000000000003 030000000000000000000000000000000000000000000000000000000000000004 - beginning of open_channel message
  		// 030053 - inbound read from peer id 0 of len 83
  		// 030000000000000000000000000000000000000000000000000000000000000005 020900000000000000000000000000000000000000000000000000000000000000 01 03000000000000000000000000000000 - rest of open_channel and mac
  		//
@@@ -711,12 -695,12 +710,12 @@@
  		// 0010 00022000 00022000 01000000000000000000000000000000 - init message (type 16) with static_remotekey (0x2000) and mac
  		//
  		// 05 01 030200000000000000000000000000000000000000000000000000000000000000 00c350 0003e8 - create outbound channel to peer 1 for 50k sat
- 		// 00fd00fd - Two feerate requests (all returning min feerate) (gonna be ingested by FuzzEstimator)
+ 		// 00fd - One feerate requests (all returning min feerate) (gonna be ingested by FuzzEstimator)
  		//
  		// 030112 - inbound read from peer id 1 of len 18
  		// 0110 01000000000000000000000000000000 - message header indicating message length 272
  		// 0301ff - inbound read from peer id 1 of len 255
- 		// 0021 0000000000000000000000000000000000000000000000000000000000000e05 000000000000001a 00000000004c4b40 00000000000003e8 00000000000003e8 00000002 03f0 0005 030000000000000000000000000000000000000000000000000000000000000100 030000000000000000000000000000000000000000000000000000000000000200 030000000000000000000000000000000000000000000000000000000000000300 030000000000000000000000000000000000000000000000000000000000000400 030000000000000000000000000000000000000000000000000000000000000500 02660000000000000000000000000000 - beginning of accept_channel
+ 		// 0021 0000000000000000000000000000000000000000000000000000000000000e05 000000000000014a 00000000004c4b40 00000000000003e8 00000000000003e8 00000002 03f0 0005 030000000000000000000000000000000000000000000000000000000000000100 030000000000000000000000000000000000000000000000000000000000000200 030000000000000000000000000000000000000000000000000000000000000300 030000000000000000000000000000000000000000000000000000000000000400 030000000000000000000000000000000000000000000000000000000000000500 02660000000000000000000000000000 - beginning of accept_channel
  		// 030121 - inbound read from peer id 1 of len 33
  		// 0000000000000000000000000000000000 01000000000000000000000000000000 - rest of accept_channel and mac
  		//
@@@ -875,7 -859,7 +874,7 @@@
  		// 030012 - inbound read from peer id 0 of len 18
  		// 05ac 03000000000000000000000000000000 - message header indicating message length 1452
  		// 0300ff - inbound read from peer id 0 of len 255
- 		// 0080 3d00000000000000000000000000000000000000000000000000000000000000 0000000000000002 00000000000b0838 ff00000000000000000000000000000000000000000000000000000000000000 00000121 00 030000000000000000000000000000000000000000000000000000000000000555 0000000e0000010000000000000003e8000000007b0000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000 ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - beginning of update_add_htlc from 0 to 1 via client
+ 		// 0080 3d00000000000000000000000000000000000000000000000000000000000000 0000000000000002 00000000000b0838 ff00000000000000000000000000000000000000000000000000000000000000 00000121 00 030000000000000000000000000000000000000000000000000000000000000555 0000000e000001000000000000000927c00000007b0000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000 ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - beginning of update_add_htlc from 0 to 1 via client
  		// 0300ff - inbound read from peer id 0 of len 255
  		// ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
  		// 0300ff - inbound read from peer id 0 of len 255
@@@ -885,7 -869,7 +884,7 @@@
  		// 0300ff - inbound read from peer id 0 of len 255
  		// ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
  		// 0300c1 - inbound read from peer id 0 of len 193
- 		// ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 9500000000000000000000000000000000000000000000000000000000000000 03000000000000000000000000000000 - end of update_add_htlc from 0 to 1 via client and mac
+ 		// ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 9000000000000000000000000000000000000000000000000000000000000000 03000000000000000000000000000000 - end of update_add_htlc from 0 to 1 via client and mac
  		//
  		// 00fd - A feerate request (returning min feerate, which our open_channel also uses) (gonna be ingested by FuzzEstimator)
  		//
@@@ -904,11 -888,11 +903,11 @@@
  		// - client now sends id 1 update_add_htlc and commitment_signed (CHECK 7 duplicate)
  		//
  		// 0c007d - connect a block with one transaction of len 125
- 		// 02000000013a0000000000000000000000000000000000000000000000000000000000000000000000000000008002000100000000000022002093000000000000000000000000000000000000000000000000000000000000006cc1000000000000160014280000000000000000000000000000000000000005000020 - the commitment transaction for channel 3f00000000000000000000000000000000000000000000000000000000000000
+ 		// 02000000013a00000000000000000000000000000000000000000000000000000000000000000000000000000080025802000000000000220020930000000000000000000000000000000000000000000000000000000000000014c0000000000000160014280000000000000000000000000000000000000005000020  - the commitment transaction for channel 3f00000000000000000000000000000000000000000000000000000000000000
  		// 00fd - A feerate request (returning min feerate, which our open_channel also uses) (gonna be ingested by FuzzEstimator)
  		// 00fd - A feerate request (returning min feerate, which our open_channel also uses) (gonna be ingested by FuzzEstimator)
  		// 0c005e - connect a block with one transaction of len 94
- 		// 02000000018900000000000000000000000000000000000000000000000000000000000000000000000000000000014f00000000000000220020b20000000000000000000000000000000000000000000000000000000000000000000000 - the HTLC timeout transaction
+ 		// 0200000001ab0000000000000000000000000000000000000000000000000000000000000000000000000000000001a701000000000000220020b20000000000000000000000000000000000000000000000000000000000000000000000 - the HTLC timeout transaction
  		// 0c0000 - connect a block with no transactions
  		// 0c0000 - connect a block with no transactions
  		// 00fd - A feerate request (returning min feerate, which our open_channel also uses) (gonna be ingested by FuzzEstimator)
@@@ -920,7 -904,7 +919,7 @@@
  		// - client now fails the HTLC backwards as it was unable to extract the payment preimage (CHECK 9 duplicate and CHECK 10)
  
  		let logger = Arc::new(TrackingLogger { lines: Mutex::new(HashMap::new()) });
- 		super::do_test(&::hex::decode("01000000000000000000000000000000000000000000000000000000000000000000000001000300000000000000000000000000000000000000000000000000000000000000020300320003000000000000000000000000000000000000000000000000000000000000000203000000000000000000000000000000030012000a0300000000000000000000000000000003001a00100002200000022000030000000000000000000000000000000300120141030000000000000000000000000000000300fe00207500000000000000000000000000000000000000000000000000000000000000ff4f00f805273c1b203bb5ebf8436bfde57b3be8c2f5e95d9491dbb181909679000000000000c35000000000000000000000000000000222ffffffffffffffff00000000000002220000000000000000000000fd000601e3030000000000000000000000000000000000000000000000000000000000000001030000000000000000000000000000000000000000000000000000000000000002030000000000000000000000000000000000000000000000000000000000000003030000000000000000000000000000000000000000000000000000000000000004030053030000000000000000000000000000000000000000000000000000000000000005020900000000000000000000000000000000000000000000000000000000000000010300000000000000000000000000000000fd00fd00fd0300120084030000000000000000000000000000000300940022ff4f00f805273c1b203bb5ebf8436bfde57b3be8c2f5e95d9491dbb1819096793d00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000210100000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000c005e020000000100000000000000000000000000000000000000000000000000000000000000000000000000ffffffff0150c3000000000000220020ae00000000000000000000000000000000000000000000000000000000000000000000000c00000c00000c00000c00000c00000c00000c00000c00000c00000c00000c00000c000003001200430300000000000000000000000000000003005300243d0000000000000000000000000000000000000000000000000000000000000002080000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000010301320003000000000000000000000000000000000000000000000000000000000000000703000000000000000000000000000000030142000302000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000003000000000000000000000000000000030112000a0100000000000000000000000000000003011a0010000220000002200001000000000000000000000000000000050103020000000000000000000000000000000000000000000000000000000000000000c3500003e800fd00fd0301120110010000000000000000000000000000000301ff00210000000000000000000000000000000000000000000000000000000000000e05000000000000001a00000000004c4b4000000000000003e800000000000003e80000000203f00005030000000000000000000000000000000000000000000000000000000000000100030000000000000000000000000000000000000000000000000000000000000200030000000000000000000000000000000000000000000000000000000000000300030000000000000000000000000000000000000000000000000000000000000400030000000000000000000000000000000000000000000000000000000000000500026600000000000000000000000000000301210000000000000000000000000000000000010000000000000000000000000000000a03011200620100000000000000000000000000000003017200233a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007c0001000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000b03011200430100000000000000000000000000000003015300243a000000000000000000000000000000000000000000000000000000000000000267000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000003001205ac030000000000000000000000000000000300ff00803d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003e80ff0000000000000000000000000000000000000000000000000000000000000000000121000300000000000000000000000000000000000000000000000000000000000005550000000e000001000000000000000003e80000007b0000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300c1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff95000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000fd03001200640300000000000000000000000000000003007400843d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030010000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000003001200630300000000000000000000000000000003007300853d000000000000000000000000000000000000000000000000000000000000000900000000000000000000000000000000000000000000000000000000000000020b00000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000703011200640100000000000000000000000000000003017400843a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006a000100000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000003011200630100000000000000000000000000000003017300853a00000000000000000000000000000000000000000000000000000000000000660000000000000000000000000000000000000000000000000000000000000002640000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000030112004a0100000000000000000000000000000003015a00823a000000000000000000000000000000000000000000000000000000000000000000000000000000ff008888888888888888888888888888888888888888888888888888888888880100000000000000000000000000000003011200640100000000000000000000000000000003017400843a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000100000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000003011200630100000000000000000000000000000003017300853a0000000000000000000000000000000000000000000000000000000000000067000000000000000000000000000000000000000000000000000000000000000265000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000003001205ac030000000000000000000000000000000300ff00803d0000000000000000000000000000000000000000000000000000000000000000000000000000010000000000003e80ff0000000000000000000000000000000000000000000000000000000000000000000121000300000000000000000000000000000000000000000000000000000000000005550000000e000001000000000000000003e80000007b0000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300c1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff95000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000fd03001200630300000000000000000000000000000003007300853d000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000020a000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000003001200640300000000000000000000000000000003007400843d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c3010000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000003001200630300000000000000000000000000000003007300853d000000000000000000000000000000000000000000000000000000000000000b00000000000000000000000000000000000000000000000000000000000000020d00000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000703011200640100000000000000000000000000000003017400843a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000039000100000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000003011200630100000000000000000000000000000003017300853a00000000000000000000000000000000000000000000000000000000000000640000000000000000000000000000000000000000000000000000000000000002700000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000030112002c0100000000000000000000000000000003013c00833a00000000000000000000000000000000000000000000000000000000000000000000000000000100000100000000000000000000000000000003011200640100000000000000000000000000000003017400843a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000039000100000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000003011200630100000000000000000000000000000003017300853a000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000027100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000703001200630300000000000000000000000000000003007300853d000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000020c000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000003001200640300000000000000000000000000000003007400843d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032010000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000003001205ac030000000000000000000000000000000300ff00803d00000000000000000000000000000000000000000000000000000000000000000000000000000200000000000b0838ff0000000000000000000000000000000000000000000000000000000000000000000121000300000000000000000000000000000000000000000000000000000000000005550000000e0000010000000000000003e8000000007b0000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0300c1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff95000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000fd03001200a4030000000000000000000000000000000300b400843d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a60100000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000b405000000000000000000000000000000000000000000000000000000000000060300000000000000000000000000000003001200630300000000000000000000000000000003007300853d000000000000000000000000000000000000000000000000000000000000000d00000000000000000000000000000000000000000000000000000000000000020f0000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000070c007d02000000013a0000000000000000000000000000000000000000000000000000000000000000000000000000008002000100000000000022002093000000000000000000000000000000000000000000000000000000000000006cc100000000000016001428000000000000000000000000000000000000000500002000fd00fd0c005e02000000018900000000000000000000000000000000000000000000000000000000000000000000000000000000014f00000000000000220020b200000000000000000000000000000000000000000000000000000000000000000000000c00000c000000fd0c00000c00000c000007").unwrap(), &(Arc::clone(&logger) as Arc<dyn Logger>));
+ 		super::do_test(&::hex::decode("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").unwrap(), &(Arc::clone(&logger) as Arc<dyn Logger>));
  
  		let log_entries = logger.lines.lock().unwrap();
  		assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling SendAcceptChannel event in peer_handler for node 030000000000000000000000000000000000000000000000000000000000000002 for channel ff4f00f805273c1b203bb5ebf8436bfde57b3be8c2f5e95d9491dbb181909679".to_string())), Some(&1)); // 1
@@@ -932,6 -916,6 +931,6 @@@
  		assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling UpdateHTLCs event in peer_handler for node 030200000000000000000000000000000000000000000000000000000000000000 with 1 adds, 0 fulfills, 0 fails for channel 3a00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&3)); // 7
  		assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling UpdateHTLCs event in peer_handler for node 030000000000000000000000000000000000000000000000000000000000000002 with 0 adds, 1 fulfills, 0 fails for channel 3d00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&1)); // 8
  		assert_eq!(log_entries.get(&("lightning::ln::peer_handler".to_string(), "Handling UpdateHTLCs event in peer_handler for node 030000000000000000000000000000000000000000000000000000000000000002 with 0 adds, 0 fulfills, 1 fails for channel 3d00000000000000000000000000000000000000000000000000000000000000".to_string())), Some(&2)); // 9
- 		assert_eq!(log_entries.get(&("lightning::chain::channelmonitor".to_string(), "Input spending counterparty commitment tx (0000000000000000000000000000000000000000000000000000000000000089:0) in 0000000000000000000000000000000000000000000000000000000000000074 resolves outbound HTLC with payment hash ff00000000000000000000000000000000000000000000000000000000000000 with timeout".to_string())), Some(&1)); // 10
+ 		assert_eq!(log_entries.get(&("lightning::chain::channelmonitor".to_string(), "Input spending counterparty commitment tx (00000000000000000000000000000000000000000000000000000000000000ab:0) in 00000000000000000000000000000000000000000000000000000000000000bf resolves outbound HTLC with payment hash ff00000000000000000000000000000000000000000000000000000000000000 with timeout".to_string())), Some(&1)); // 10
  	}
  }
diff --combined lightning/src/ln/channel.rs
index fc59c29d7,4d592dc55..413dc8313
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@@ -21,11 -21,10 +21,11 @@@ use bitcoin::secp256k1::key::{PublicKey
  use bitcoin::secp256k1::{Secp256k1,Signature};
  use bitcoin::secp256k1;
  
 +use ln::{PaymentPreimage, PaymentHash};
  use ln::features::{ChannelFeatures, InitFeatures};
  use ln::msgs;
  use ln::msgs::{DecodeError, OptionalField, DataLossProtect};
 -use ln::channelmanager::{BestBlock, PendingHTLCStatus, HTLCSource, HTLCFailReason, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, PaymentPreimage, PaymentHash, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
 +use ln::channelmanager::{BestBlock, PendingHTLCStatus, HTLCSource, HTLCFailReason, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
  use ln::chan_utils::{CounterpartyCommitmentSecrets, TxCreationKeys, HTLCOutputInCommitment, HTLC_SUCCESS_TX_WEIGHT, HTLC_TIMEOUT_TX_WEIGHT, make_funding_redeemscript, ChannelPublicKeys, CommitmentTransaction, HolderCommitmentTransaction, ChannelTransactionParameters, CounterpartyChannelTransactionParameters, MAX_HTLCS, get_commitment_transaction_number_obscure_factor};
  use ln::chan_utils;
  use chain::chaininterface::{FeeEstimator,ConfirmationTarget};
@@@ -439,7 -438,6 +439,6 @@@ struct CommitmentTxInfoCached 
  
  pub const OUR_MAX_HTLCS: u16 = 50; //TODO
  const SPENDING_INPUT_FOR_A_OUTPUT_WEIGHT: u64 = 79; // prevout: 36, nSequence: 4, script len: 1, witness lengths: (3+1)/4, sig: 73/4, if-selector: 1, redeemScript: (6 ops + 2*33 pubkeys + 1*2 delay)/4
- const B_OUTPUT_PLUS_SPENDING_INPUT_WEIGHT: u64 = 104; // prevout: 40, nSequence: 4, script len: 1, witness lengths: 3/4, sig: 73/4, pubkey: 33/4, output: 31 (TODO: Wrong? Useless?)
  
  #[cfg(not(test))]
  const COMMITMENT_TX_BASE_WEIGHT: u64 = 724;
@@@ -454,6 -452,22 +453,22 @@@ pub const COMMITMENT_TX_WEIGHT_PER_HTLC
  /// it's 2^24.
  pub const MAX_FUNDING_SATOSHIS: u64 = 1 << 24;
  
+ /// Maximum counterparty `dust_limit_satoshis` allowed. 2 * standard dust threshold on p2wsh output
+ /// Scales up on Bitcoin Core's proceeding policy with dust outputs. A typical p2wsh output is 43
+ /// bytes to which Core's `GetDustThreshold()` sums up a minimal spend of 67 bytes (even if
+ /// a p2wsh witnessScript might be *effectively* smaller), `dustRelayFee` is set to 3000sat/kb, thus
+ /// 110 * 3000 / 1000 = 330. Per-protocol rules, all time-sensitive outputs are p2wsh, a value of
+ /// 330 sats is the lower bound desired to ensure good propagation of transactions. We give a bit
+ /// of margin to our counterparty and pick up 660 satoshis as an accepted `dust_limit_satoshis`
+ /// upper bound to avoid negotiation conflicts with other implementations.
+ pub const MAX_DUST_LIMIT_SATOSHIS: u64 = 2 * 330;
+ 
+ /// A typical p2wsh output is 43 bytes to which Core's `GetDustThreshold()` sums up a minimal
+ /// spend of 67 bytes (even if a p2wsh witnessScript might be *effectively* smaller), `dustRelayFee`
+ /// is set to 3000sat/kb, thus 110 * 3000 / 1000 = 330. Per-protocol rules, all time-sensitive outputs
+ /// are p2wsh, a value of 330 sats is the lower bound desired to ensure good propagation of transactions.
+ pub const MIN_DUST_LIMIT_SATOSHIS: u64 = 330;
+ 
  /// Used to return a simple Error back to ChannelManager. Will get converted to a
  /// msgs::ErrorAction::SendErrorMessage or msgs::ErrorAction::IgnoreError as appropriate with our
  /// channel_id in ChannelManager.
@@@ -497,10 -511,6 +512,6 @@@ impl<Signer: Sign> Channel<Signer> 
  		cmp::min(channel_value_satoshis, cmp::max(q, 1000)) //TODO
  	}
  
- 	fn derive_holder_dust_limit_satoshis(at_open_background_feerate: u32) -> u64 {
- 		cmp::max(at_open_background_feerate as u64 * B_OUTPUT_PLUS_SPENDING_INPUT_WEIGHT / 1000, 546) //TODO
- 	}
- 
  	// Constructors:
  	pub fn new_outbound<K: Deref, F: Deref>(fee_estimator: &F, keys_provider: &K, counterparty_node_id: PublicKey, channel_value_satoshis: u64, push_msat: u64, user_id: u64, config: &UserConfig) -> Result<Channel<Signer>, APIError>
  	where K::Target: KeysInterface<Signer = Signer>,
@@@ -520,9 -530,9 +531,9 @@@
  		if holder_selected_contest_delay < BREAKDOWN_TIMEOUT {
  			return Err(APIError::APIMisuseError {err: format!("Configured with an unreasonable our_to_self_delay ({}) putting user funds at risks", holder_selected_contest_delay)});
  		}
- 		let background_feerate = fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::Background);
- 		if Channel::<Signer>::get_holder_selected_channel_reserve_satoshis(channel_value_satoshis) < Channel::<Signer>::derive_holder_dust_limit_satoshis(background_feerate) {
- 			return Err(APIError::FeeRateTooHigh{err: format!("Not enough reserve above dust limit can be found at current fee rate({})", background_feerate), feerate: background_feerate});
+ 		let holder_selected_channel_reserve_satoshis = Channel::<Signer>::get_holder_selected_channel_reserve_satoshis(channel_value_satoshis);
+ 		if holder_selected_channel_reserve_satoshis < MIN_DUST_LIMIT_SATOSHIS {
+ 			return Err(APIError::APIMisuseError { err: format!("Holder selected channel  reserve below implemention limit dust_limit_satoshis {}", holder_selected_channel_reserve_satoshis) });
  		}
  
  		let feerate = fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::Normal);
@@@ -579,7 -589,7 +590,7 @@@
  
  			feerate_per_kw: feerate,
  			counterparty_dust_limit_satoshis: 0,
- 			holder_dust_limit_satoshis: Channel::<Signer>::derive_holder_dust_limit_satoshis(background_feerate),
+ 			holder_dust_limit_satoshis: MIN_DUST_LIMIT_SATOSHIS,
  			counterparty_max_htlc_value_in_flight_msat: 0,
  			counterparty_selected_channel_reserve_satoshis: 0,
  			counterparty_htlc_minimum_msat: 0,
@@@ -700,11 -710,11 +711,11 @@@
  		if msg.max_accepted_htlcs < config.peer_channel_config_limits.min_max_accepted_htlcs {
  			return Err(ChannelError::Close(format!("max_accepted_htlcs ({}) is less than the user specified limit ({})", msg.max_accepted_htlcs, config.peer_channel_config_limits.min_max_accepted_htlcs)));
  		}
- 		if msg.dust_limit_satoshis < config.peer_channel_config_limits.min_dust_limit_satoshis {
- 			return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is less than the user specified limit ({})", msg.dust_limit_satoshis, config.peer_channel_config_limits.min_dust_limit_satoshis)));
+ 		if msg.dust_limit_satoshis < MIN_DUST_LIMIT_SATOSHIS {
+ 			return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is less than the implementation limit ({})", msg.dust_limit_satoshis, MIN_DUST_LIMIT_SATOSHIS)));
  		}
- 		if msg.dust_limit_satoshis > config.peer_channel_config_limits.max_dust_limit_satoshis {
- 			return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is greater than the user specified limit ({})", msg.dust_limit_satoshis, config.peer_channel_config_limits.max_dust_limit_satoshis)));
+ 		if msg.dust_limit_satoshis >  MAX_DUST_LIMIT_SATOSHIS {
+ 			return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is greater than the implementation limit ({})", msg.dust_limit_satoshis, MAX_DUST_LIMIT_SATOSHIS)));
  		}
  
  		// Convert things into internal flags and prep our state:
@@@ -720,13 -730,12 +731,12 @@@
  
  		let background_feerate = fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::Background);
  
- 		let holder_dust_limit_satoshis = Channel::<Signer>::derive_holder_dust_limit_satoshis(background_feerate);
  		let holder_selected_channel_reserve_satoshis = Channel::<Signer>::get_holder_selected_channel_reserve_satoshis(msg.funding_satoshis);
- 		if holder_selected_channel_reserve_satoshis < holder_dust_limit_satoshis {
- 			return Err(ChannelError::Close(format!("Suitable channel reserve not found. remote_channel_reserve was ({}). dust_limit_satoshis is ({}).", holder_selected_channel_reserve_satoshis, holder_dust_limit_satoshis)));
+ 		if holder_selected_channel_reserve_satoshis < MIN_DUST_LIMIT_SATOSHIS {
+ 			return Err(ChannelError::Close(format!("Suitable channel reserve not found. remote_channel_reserve was ({}). dust_limit_satoshis is ({}).", holder_selected_channel_reserve_satoshis, MIN_DUST_LIMIT_SATOSHIS)));
  		}
- 		if msg.channel_reserve_satoshis < holder_dust_limit_satoshis {
- 			return Err(ChannelError::Close(format!("channel_reserve_satoshis ({}) is smaller than our dust limit ({})", msg.channel_reserve_satoshis, holder_dust_limit_satoshis)));
+ 		if msg.channel_reserve_satoshis < MIN_DUST_LIMIT_SATOSHIS {
+ 			return Err(ChannelError::Close(format!("channel_reserve_satoshis ({}) is smaller than our dust limit ({})", msg.channel_reserve_satoshis, MIN_DUST_LIMIT_SATOSHIS)));
  		}
  		if holder_selected_channel_reserve_satoshis < msg.dust_limit_satoshis {
  			return Err(ChannelError::Close(format!("Dust limit ({}) too high for the channel reserve we require the remote to keep ({})", msg.dust_limit_satoshis, holder_selected_channel_reserve_satoshis)));
@@@ -818,7 -827,7 +828,7 @@@
  			feerate_per_kw: msg.feerate_per_kw,
  			channel_value_satoshis: msg.funding_satoshis,
  			counterparty_dust_limit_satoshis: msg.dust_limit_satoshis,
- 			holder_dust_limit_satoshis,
+ 			holder_dust_limit_satoshis: MIN_DUST_LIMIT_SATOSHIS,
  			counterparty_max_htlc_value_in_flight_msat: cmp::min(msg.max_htlc_value_in_flight_msat, msg.funding_satoshis * 1000),
  			counterparty_selected_channel_reserve_satoshis: msg.channel_reserve_satoshis,
  			counterparty_htlc_minimum_msat: msg.htlc_minimum_msat,
@@@ -1442,11 -1451,11 +1452,11 @@@
  		if msg.max_accepted_htlcs < config.peer_channel_config_limits.min_max_accepted_htlcs {
  			return Err(ChannelError::Close(format!("max_accepted_htlcs ({}) is less than the user specified limit ({})", msg.max_accepted_htlcs, config.peer_channel_config_limits.min_max_accepted_htlcs)));
  		}
- 		if msg.dust_limit_satoshis < config.peer_channel_config_limits.min_dust_limit_satoshis {
- 			return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is less than the user specified limit ({})", msg.dust_limit_satoshis, config.peer_channel_config_limits.min_dust_limit_satoshis)));
+ 		if msg.dust_limit_satoshis < MIN_DUST_LIMIT_SATOSHIS {
+ 			return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is less than the implementation limit ({})", msg.dust_limit_satoshis, MIN_DUST_LIMIT_SATOSHIS)));
  		}
- 		if msg.dust_limit_satoshis > config.peer_channel_config_limits.max_dust_limit_satoshis {
- 			return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is greater than the user specified limit ({})", msg.dust_limit_satoshis, config.peer_channel_config_limits.max_dust_limit_satoshis)));
+ 		if msg.dust_limit_satoshis > MAX_DUST_LIMIT_SATOSHIS {
+ 			return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is greater than the implementation limit ({})", msg.dust_limit_satoshis, MAX_DUST_LIMIT_SATOSHIS)));
  		}
  		if msg.minimum_depth > config.peer_channel_config_limits.max_minimum_depth {
  			return Err(ChannelError::Close(format!("We consider the minimum depth to be unreasonably large. Expected minimum: ({}). Actual: ({})", config.peer_channel_config_limits.max_minimum_depth, msg.minimum_depth)));
@@@ -4825,8 -4834,7 +4835,8 @@@ mod tests 
  	use bitcoin::network::constants::Network;
  	use bitcoin::hashes::hex::FromHex;
  	use hex;
 -	use ln::channelmanager::{BestBlock, HTLCSource, PaymentPreimage, PaymentHash};
 +	use ln::{PaymentPreimage, PaymentHash};
 +	use ln::channelmanager::{BestBlock, HTLCSource};
  	use ln::channel::{Channel,InboundHTLCOutput,OutboundHTLCOutput,InboundHTLCState,OutboundHTLCState,HTLCOutputInCommitment,HTLCCandidate,HTLCInitiator,TxCreationKeys};
  	use ln::channel::MAX_FUNDING_SATOSHIS;
  	use ln::features::InitFeatures;
@@@ -4843,7 -4851,6 +4853,7 @@@
  	use bitcoin::secp256k1::{Secp256k1, Message, Signature, All};
  	use bitcoin::secp256k1::ffi::Signature as FFISignature;
  	use bitcoin::secp256k1::key::{SecretKey,PublicKey};
 +	use bitcoin::secp256k1::recovery::RecoverableSignature;
  	use bitcoin::hashes::sha256::Hash as Sha256;
  	use bitcoin::hashes::Hash;
  	use bitcoin::hash_types::{Txid, WPubkeyHash};
@@@ -4889,7 -4896,6 +4899,7 @@@
  		}
  		fn get_secure_random_bytes(&self) -> [u8; 32] { [0; 32] }
  		fn read_chan_signer(&self, _data: &[u8]) -> Result<Self::Signer, DecodeError> { panic!(); }
 +		fn sign_invoice(&self, _invoice_preimage: Vec<u8>) -> Result<RecoverableSignature, ()> { panic!(); }
  	}
  
  	fn public_from_secret_hex(secp_ctx: &Secp256k1<All>, hex: &str) -> PublicKey {
@@@ -4939,7 -4945,6 +4949,6 @@@
  		// Create Node B's channel by receiving Node A's open_channel message
  		// Make sure A's dust limit is as we expect.
  		let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.block_hash());
- 		assert_eq!(open_channel_msg.dust_limit_satoshis, 1560);
  		let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
  		let node_b_chan = Channel::<EnforcingSigner>::new_from_req(&&feeest, &&keys_provider, node_b_node_id, InitFeatures::known(), &open_channel_msg, 7, &config).unwrap();
  
@@@ -4947,6 -4952,7 +4956,7 @@@
  		let mut accept_channel_msg = node_b_chan.get_accept_channel();
  		accept_channel_msg.dust_limit_satoshis = 546;
  		node_a_chan.accept_channel(&accept_channel_msg, &config, InitFeatures::known()).unwrap();
+ 		node_a_chan.holder_dust_limit_satoshis = 1560;
  
  		// Put some inbound and outbound HTLCs in A's channel.
  		let htlc_amount_msat = 11_092_000; // put an amount below A's effective dust limit but above B's.
diff --combined lightning/src/ln/functional_tests.rs
index 6d6e0937c,d95b73651..d67f9337c
--- a/lightning/src/ln/functional_tests.rs
+++ b/lightning/src/ln/functional_tests.rs
@@@ -18,13 -18,12 +18,13 @@@ use chain::channelmonitor
  use chain::channelmonitor::{ChannelMonitor, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS, ANTI_REORG_DELAY};
  use chain::transaction::OutPoint;
  use chain::keysinterface::{KeysInterface, BaseSign};
 +use ln::{PaymentPreimage, PaymentSecret, PaymentHash};
  use ln::channel::{COMMITMENT_TX_BASE_WEIGHT, COMMITMENT_TX_WEIGHT_PER_HTLC};
 -use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash, PaymentSecret, PaymentSendFailure, BREAKDOWN_TIMEOUT};
 +use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentSendFailure, BREAKDOWN_TIMEOUT};
  use ln::channel::{Channel, ChannelError};
  use ln::{chan_utils, onion_utils};
  use routing::router::{Route, RouteHop, get_route};
 -use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
 +use ln::features::{ChannelFeatures, InitFeatures, InvoiceFeatures, NodeFeatures};
  use ln::msgs;
  use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler,HTLCFailChannelUpdate, ErrorAction};
  use util::enforcing_trait_impls::EnforcingSigner;
@@@ -129,7 -128,7 +129,7 @@@ fn test_async_inbound_update_fee() 
  	let channel_id = chan.2;
  
  	// balancing
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
  
  	// A                                        B
  	// update_fee                            ->
@@@ -164,9 -163,9 +164,9 @@@
  	nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
  
  	// ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]...
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[0]);
  	let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -	nodes[1].node.send_payment(&get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger).unwrap(), our_payment_hash, &None).unwrap();
 +	nodes[1].node.send_payment(&get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger).unwrap(), our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[1], 1);
  
  	let payment_event = {
@@@ -244,7 -243,7 +244,7 @@@ fn test_update_fee_unordered_raa() 
  	let logger = test_utils::TestLogger::new();
  
  	// balancing
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
  
  	// First nodes[0] generates an update_fee
  	nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
@@@ -262,9 -261,9 +262,9 @@@
  	nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
  
  	// ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]...
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[0]);
  	let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -	nodes[1].node.send_payment(&get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger).unwrap(), our_payment_hash, &None).unwrap();
 +	nodes[1].node.send_payment(&get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger).unwrap(), our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[1], 1);
  
  	let payment_event = {
@@@ -626,7 -625,7 +626,7 @@@ fn test_update_fee_with_fundee_update_a
  	let logger = test_utils::TestLogger::new();
  
  	// balancing
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
  
  	let feerate = get_feerate!(nodes[0], channel_id);
  	nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
@@@ -645,12 -644,12 +645,12 @@@
  	let (revoke_msg, commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
  	check_added_monitors!(nodes[1], 1);
  
 -	let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[1]);
 +	let (our_payment_preimage, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[0]);
  	let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -	let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, None, &Vec::new(), 800000, TEST_FINAL_CLTV, &logger).unwrap();
 +	let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 800000, TEST_FINAL_CLTV, &logger).unwrap();
  
  	// nothing happens since node[1] is in AwaitingRemoteRevoke
 -	nodes[1].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	nodes[1].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	{
  		let mut added_monitors = nodes[0].chain_monitor.added_monitors.lock().unwrap();
  		assert_eq!(added_monitors.len(), 0);
@@@ -706,10 -705,10 +706,10 @@@
  		_ => panic!("Unexpected event"),
  	};
  
 -	claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage, 800_000);
 +	claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage);
  
 -	send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000, 800_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000, 800_000);
 +	send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000);
  	close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
  }
  
@@@ -855,7 -854,7 +855,7 @@@ fn updates_shutdown_wait() 
  	let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
 +	let (our_payment_preimage, _, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
  
  	nodes[0].node.close_channel(&chan_1.2).unwrap();
  	let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
@@@ -866,16 -865,16 +866,16 @@@
  	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
  
 -	let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[0]);
  
  	let net_graph_msg_handler0 = &nodes[0].net_graph_msg_handler;
  	let net_graph_msg_handler1 = &nodes[1].net_graph_msg_handler;
 -	let route_1 = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler0.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -	let route_2 = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler1.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -	unwrap_send_err!(nodes[0].node.send_payment(&route_1, payment_hash, &None), true, APIError::ChannelUnavailable {..}, {});
 -	unwrap_send_err!(nodes[1].node.send_payment(&route_2, payment_hash, &None), true, APIError::ChannelUnavailable {..}, {});
 +	let route_1 = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler0.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +	let route_2 = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler1.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +	unwrap_send_err!(nodes[0].node.send_payment(&route_1, payment_hash, &Some(payment_secret)), true, APIError::ChannelUnavailable {..}, {});
 +	unwrap_send_err!(nodes[1].node.send_payment(&route_2, payment_hash, &Some(payment_secret)), true, APIError::ChannelUnavailable {..}, {});
  
 -	assert!(nodes[2].node.claim_funds(our_payment_preimage, &None, 100_000));
 +	assert!(nodes[2].node.claim_funds(our_payment_preimage));
  	check_added_monitors!(nodes[2], 1);
  	let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
  	assert!(updates.update_add_htlcs.is_empty());
@@@ -932,10 -931,10 +932,10 @@@ fn htlc_fail_async_shutdown() 
  	let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[2]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  	let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  	assert_eq!(updates.update_add_htlcs.len(), 1);
@@@ -1009,7 -1008,7 +1009,7 @@@ fn do_test_shutdown_rebroadcast(recv_co
  	let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  	let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
 -	let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
 +	let (our_payment_preimage, _, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
  
  	nodes[1].node.close_channel(&chan_1.2).unwrap();
  	let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
@@@ -1048,7 -1047,7 +1048,7 @@@
  	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
  
 -	assert!(nodes[2].node.claim_funds(our_payment_preimage, &None, 100_000));
 +	assert!(nodes[2].node.claim_funds(our_payment_preimage));
  	check_added_monitors!(nodes[2], 1);
  	let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
  	assert!(updates.update_add_htlcs.is_empty());
@@@ -1176,15 -1175,15 +1176,15 @@@ fn fake_network_test() 
  	let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
  
  	// Rebalance the network a bit by relaying one payment through all the channels...
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
  
  	// Send some more payments
 -	send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000, 1_000_000);
 -	send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000, 1_000_000);
 -	send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000, 1_000_000);
 +	send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000);
 +	send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000);
 +	send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000);
  
  	// Test failure packets
  	let payment_hash_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 1000000).1;
@@@ -1193,13 -1192,13 +1193,13 @@@
  	// Add a new channel that skips 3
  	let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
  
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000, 1_000_000);
 -	send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000, 1_000_000);
 -	send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000);
 +	send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000);
 +	send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
 +	send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
 +	send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
 +	send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
 +	send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
  
  	// Do some rebalance loop payments, simultaneously
  	let mut hops = Vec::with_capacity(3);
@@@ -1221,9 -1220,9 +1221,9 @@@
  	});
  	hops.push(RouteHop {
  		pubkey: nodes[1].node.get_our_node_id(),
 -		node_features: NodeFeatures::empty(),
 +		node_features: NodeFeatures::known(),
  		short_channel_id: chan_4.0.contents.short_channel_id,
 -		channel_features: ChannelFeatures::empty(),
 +		channel_features: ChannelFeatures::known(),
  		fee_msat: 1000000,
  		cltv_expiry_delta: TEST_FINAL_CLTV,
  	});
@@@ -1250,9 -1249,9 +1250,9 @@@
  	});
  	hops.push(RouteHop {
  		pubkey: nodes[1].node.get_our_node_id(),
 -		node_features: NodeFeatures::empty(),
 +		node_features: NodeFeatures::known(),
  		short_channel_id: chan_2.0.contents.short_channel_id,
 -		channel_features: ChannelFeatures::empty(),
 +		channel_features: ChannelFeatures::known(),
  		fee_msat: 1000000,
  		cltv_expiry_delta: TEST_FINAL_CLTV,
  	});
@@@ -1262,7 -1261,7 +1262,7 @@@
  
  	// Claim the rebalances...
  	fail_payment(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_hash_2);
 -	claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1, 1_000_000);
 +	claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1);
  
  	// Add a duplicate new channel from 2 to 4
  	let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
@@@ -1280,9 -1279,9 +1280,9 @@@
  
  	//TODO: Test that routes work again here as we've been notified that the channel is full
  
 -	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3, 3_000_000);
 -	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4, 3_000_000);
 -	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3);
 +	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4);
 +	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5);
  
  	// Close down the channels...
  	close_channel(&nodes[0], &nodes[1], &chan_1.2, chan_1.3, true);
@@@ -1307,10 -1306,10 +1307,10 @@@ fn holding_cell_htlc_counting() 
  
  	let mut payments = Vec::new();
  	for _ in 0..::ln::channel::OUR_MAX_HTLCS {
 -		let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +		let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[2]);
  		let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[1].node.send_payment(&route, payment_hash, &None).unwrap();
 +		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[1].node.send_payment(&route, payment_hash, &Some(payment_secret)).unwrap();
  		payments.push((payment_preimage, payment_hash));
  	}
  	check_added_monitors!(nodes[1], 1);
@@@ -1323,22 -1322,22 +1323,22 @@@
  	// There is now one HTLC in an outbound commitment transaction and (OUR_MAX_HTLCS - 1) HTLCs in
  	// the holding cell waiting on B's RAA to send. At this point we should not be able to add
  	// another HTLC.
 -	let (_, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, payment_hash_1, payment_secret_1) = get_payment_preimage_hash!(nodes[2]);
  	{
  		let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -		unwrap_send_err!(nodes[1].node.send_payment(&route, payment_hash_1, &None), true, APIError::ChannelUnavailable { ref err },
 +		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +		unwrap_send_err!(nodes[1].node.send_payment(&route, payment_hash_1, &Some(payment_secret_1)), true, APIError::ChannelUnavailable { ref err },
  			assert!(regex::Regex::new(r"Cannot push more than their max accepted HTLCs \(\d+\)").unwrap().is_match(err)));
  		assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
  		nodes[1].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot push more than their max accepted HTLCs".to_string(), 1);
  	}
  
  	// This should also be true if we try to forward a payment.
 -	let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, payment_hash_2, payment_secret_2) = get_payment_preimage_hash!(nodes[2]);
  	{
  		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[0].node.send_payment(&route, payment_hash_2, &Some(payment_secret_2)).unwrap();
  		check_added_monitors!(nodes[0], 1);
  	}
  
@@@ -1416,10 -1415,10 +1416,10 @@@
  	}
  
  	for (preimage, _) in payments.drain(..) {
 -		claim_payment(&nodes[1], &[&nodes[2]], preimage, 100_000);
 +		claim_payment(&nodes[1], &[&nodes[2]], preimage);
  	}
  
 -	send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000, 1_000_000);
 +	send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
  }
  
  #[test]
@@@ -1438,7 -1437,7 +1438,7 @@@ fn duplicate_htlc_test() 
  	create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
  	create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
  
 -	let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], 1000000);
 +	let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], 1000000);
  
  	*nodes[0].network_payment_count.borrow_mut() -= 1;
  	assert_eq!(route_payment(&nodes[1], &vec!(&nodes[3])[..], 1000000).0, payment_preimage);
@@@ -1446,16 -1445,16 +1446,16 @@@
  	*nodes[0].network_payment_count.borrow_mut() -= 1;
  	assert_eq!(route_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], 1000000).0, payment_preimage);
  
 -	claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage, 1_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage);
  	fail_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], payment_hash);
 -	claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage, 1_000_000);
 +	claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage);
  }
  
  #[test]
  fn test_duplicate_htlc_different_direction_onchain() {
  	// Test that ChannelMonitor doesn't generate 2 preimage txn
  	// when we have 2 HTLCs with same preimage that go across a node
 -	// in opposite directions.
 +	// in opposite directions, even with the same payment secret.
  	let chanmon_cfgs = create_chanmon_cfgs(2);
  	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
  	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
@@@ -1465,17 -1464,16 +1465,17 @@@
  	let logger = test_utils::TestLogger::new();
  
  	// balancing
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
  
 -	let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 900_000);
 +	let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 900_000);
  
  	let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -	let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, None, &Vec::new(), 800_000, TEST_FINAL_CLTV, &logger).unwrap();
 -	send_along_route_with_hash(&nodes[1], route, &vec!(&nodes[0])[..], 800_000, payment_hash);
 +	let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 800_000, TEST_FINAL_CLTV, &logger).unwrap();
 +	let node_a_payment_secret = nodes[0].node.create_inbound_payment_for_hash(payment_hash, None, 7200, 0).unwrap();
 +	send_along_route_with_secret(&nodes[1], route, &[&[&nodes[0]]], 800_000, payment_hash, node_a_payment_secret);
  
  	// Provide preimage to node 0 by claiming payment
 -	nodes[0].node.claim_funds(payment_preimage, &None, 800_000);
 +	nodes[0].node.claim_funds(payment_preimage);
  	check_added_monitors!(nodes[0], 1);
  
  	// Broadcast node 1 commitment txn
@@@ -1542,12 -1540,12 +1542,12 @@@ fn test_basic_channel_reserve() 
  	let channel_reserve = chan_stat.channel_reserve_msat;
  
  	// The 2* and +1 are for the fee spike reserve.
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let commit_tx_fee = 2 * commit_tx_fee_msat(get_feerate!(nodes[0], chan.2), 1 + 1);
  	let max_can_send = 5000000 - channel_reserve - commit_tx_fee;
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.last().unwrap().node.get_our_node_id(), None, None, &Vec::new(), max_can_send + 1, TEST_FINAL_CLTV, &logger).unwrap();
 -	let err = nodes[0].node.send_payment(&route, our_payment_hash, &None).err().unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.last().unwrap().node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), max_can_send + 1, TEST_FINAL_CLTV, &logger).unwrap();
 +	let err = nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).err().unwrap();
  	match err {
  		PaymentSendFailure::AllFailedRetrySafe(ref fails) => {
  			match &fails[0] {
@@@ -1561,7 -1559,7 +1561,7 @@@
  	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  	nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put our balance under counterparty-announced channel reserve value".to_string(), 1);
  
 -	send_payment(&nodes[0], &vec![&nodes[1]], max_can_send, max_can_send);
 +	send_payment(&nodes[0], &vec![&nodes[1]], max_can_send);
  }
  
  #[test]
@@@ -1571,8 -1569,18 +1571,8 @@@ fn test_fee_spike_violation_fails_htlc(
  	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  	let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
 -	let logger = test_utils::TestLogger::new();
  
 -	macro_rules! get_route_and_payment_hash {
 -		($recv_value: expr) => {{
 -			let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
 -			let net_graph_msg_handler = &nodes[0].net_graph_msg_handler.network_graph.read().unwrap();
 -			let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes.last().unwrap().node.get_our_node_id(), None, None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap();
 -			(route, payment_hash, payment_preimage)
 -		}}
 -	}
 -
 -	let (route, payment_hash, _) = get_route_and_payment_hash!(3460001);
 +	let (route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], 3460001);
  	// Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
  	let secp_ctx = Secp256k1::new();
  	let session_priv = SecretKey::from_slice(&[42; 32]).expect("RNG is bad!");
@@@ -1580,7 -1588,7 +1580,7 @@@
  	let cur_height = nodes[1].node.best_block.read().unwrap().height() + 1;
  
  	let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
 -	let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 3460001, &None, cur_height).unwrap();
 +	let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 3460001, &Some(payment_secret), cur_height).unwrap();
  	let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
  	let msg = msgs::UpdateAddHTLC {
  		channel_id: chan.2,
@@@ -1701,9 -1709,19 +1701,9 @@@ fn test_chan_reserve_violation_outbound
  	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  	let _ = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
 -	let logger = test_utils::TestLogger::new();
  
 -	macro_rules! get_route_and_payment_hash {
 -		($recv_value: expr) => {{
 -			let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
 -			let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -			let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.first().unwrap().node.get_our_node_id(), None, None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap();
 -			(route, payment_hash, payment_preimage)
 -		}}
 -	}
 -
 -	let (route, our_payment_hash, _) = get_route_and_payment_hash!(4843000);
 -	unwrap_send_err!(nodes[1].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
 +	let (route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[1], nodes[0], 4843000);
 +	unwrap_send_err!(nodes[1].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)), true, APIError::ChannelUnavailable { ref err },
  		assert_eq!(err, "Cannot send value that would put counterparty balance under holder-announced channel reserve value"));
  	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
  	nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Cannot send value that would put counterparty balance under holder-announced channel reserve value".to_string(), 1);
@@@ -1723,14 -1741,24 +1723,14 @@@ fn test_chan_reserve_violation_inbound_
  	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  	let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
 -	let logger = test_utils::TestLogger::new();
  
 -	macro_rules! get_route_and_payment_hash {
 -		($recv_value: expr) => {{
 -			let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
 -			let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -			let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.first().unwrap().node.get_our_node_id(), None, None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap();
 -			(route, payment_hash, payment_preimage)
 -		}}
 -	}
 -
 -	let (route, payment_hash, _) = get_route_and_payment_hash!(1000);
 +	let (route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[1], nodes[0], 1000);
  	// Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
  	let secp_ctx = Secp256k1::new();
  	let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
  	let cur_height = nodes[1].node.best_block.read().unwrap().height() + 1;
  	let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
 -	let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 1000, &None, cur_height).unwrap();
 +	let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 1000, &Some(payment_secret), cur_height).unwrap();
  	let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
  	let msg = msgs::UpdateAddHTLC {
  		channel_id: chan.2,
@@@ -1764,11 -1792,11 +1764,11 @@@ fn test_chan_reserve_dust_inbound_htlcs
  	// transaction fee with 0 HTLCs (183 sats)).
  	create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 98817000, InitFeatures::known(), InitFeatures::known());
  
- 	let dust_amt = 546000; // Dust amount
+ 	let dust_amt = 329000; // Dust amount
  	// In the previous code, routing this dust payment would cause nodes[0] to perceive a channel
  	// reserve violation even though it's a dust HTLC and therefore shouldn't count towards the
  	// commitment transaction fee.
 -	let (_, _) = route_payment(&nodes[1], &[&nodes[0]], dust_amt);
 +	let (_, _, _) = route_payment(&nodes[1], &[&nodes[0]], dust_amt);
  }
  
  #[test]
@@@ -1783,22 -1811,22 +1783,22 @@@ fn test_chan_reserve_dust_inbound_htlcs
  
  	let payment_amt = 46000; // Dust amount
  	// In the previous code, these first four payments would succeed.
 -	let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 -	let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 -	let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 -	let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 +	let (_, _, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 +	let (_, _, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 +	let (_, _, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 +	let (_, _, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
  
  	// Then these next 5 would be interpreted by nodes[1] as violating the fee spike buffer.
 -	let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 -	let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 -	let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 -	let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 -	let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 +	let (_, _, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 +	let (_, _, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 +	let (_, _, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 +	let (_, _, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 +	let (_, _, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
  
  	// And this last payment previously resulted in nodes[1] closing on its inbound-channel
  	// counterparty, because it counted all the previous dust HTLCs against nodes[0]'s commitment
  	// transaction fee and therefore perceived this next payment as a channel reserve violation.
 -	let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
 +	let (_, _, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt);
  }
  
  #[test]
@@@ -1809,6 -1837,16 +1809,6 @@@ fn test_chan_reserve_violation_inbound_
  	let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  	let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
  	let _ = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
 -	let logger = test_utils::TestLogger::new();
 -
 -	macro_rules! get_route_and_payment_hash {
 -		($recv_value: expr) => {{
 -			let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
 -			let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -			let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.last().unwrap().node.get_our_node_id(), None, None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap();
 -			(route, payment_hash, payment_preimage)
 -		}}
 -	}
  
  	let feemsat = 239;
  	let total_routing_fee_msat = (nodes.len() - 2) as u64 * feemsat;
@@@ -1821,9 -1859,9 +1821,9 @@@
  	let amt_msat_1 = recv_value_1 + total_routing_fee_msat;
  
  	// Add a pending HTLC.
 -	let (route_1, our_payment_hash_1, _) = get_route_and_payment_hash!(amt_msat_1);
 +	let (route_1, our_payment_hash_1, _, our_payment_secret_1) = get_route_and_payment_hash!(nodes[0], nodes[2], amt_msat_1);
  	let payment_event_1 = {
 -		nodes[0].node.send_payment(&route_1, our_payment_hash_1, &None).unwrap();
 +		nodes[0].node.send_payment(&route_1, our_payment_hash_1, &Some(our_payment_secret_1)).unwrap();
  		check_added_monitors!(nodes[0], 1);
  
  		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
@@@ -1836,7 -1874,7 +1836,7 @@@
  	let commit_tx_fee_2_htlcs = commit_tx_fee_msat(feerate, 2);
  	let recv_value_2 = chan_stat.value_to_self_msat - amt_msat_1 - chan_stat.channel_reserve_msat - total_routing_fee_msat - commit_tx_fee_2_htlcs + 1;
  	let amt_msat_2 = recv_value_2 + total_routing_fee_msat;
 -	let (route_2, _, _) = get_route_and_payment_hash!(amt_msat_2);
 +	let (route_2, _, _, _) = get_route_and_payment_hash!(nodes[0], nodes[2], amt_msat_2);
  
  	// Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
  	let secp_ctx = Secp256k1::new();
@@@ -1894,6 -1932,7 +1894,6 @@@ fn test_channel_reserve_holding_cell_ht
  	let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  	let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 190000, 1001, InitFeatures::known(), InitFeatures::known());
  	let chan_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 190000, 1001, InitFeatures::known(), InitFeatures::known());
 -	let logger = test_utils::TestLogger::new();
  
  	let mut stat01 = get_channel_value_stat!(nodes[0], chan_1.2);
  	let mut stat11 = get_channel_value_stat!(nodes[1], chan_1.2);
@@@ -1901,6 -1940,15 +1901,6 @@@
  	let mut stat12 = get_channel_value_stat!(nodes[1], chan_2.2);
  	let mut stat22 = get_channel_value_stat!(nodes[2], chan_2.2);
  
 -	macro_rules! get_route_and_payment_hash {
 -		($recv_value: expr) => {{
 -			let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
 -			let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -			let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.last().unwrap().node.get_our_node_id(), None, None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap();
 -			(route, payment_hash, payment_preimage)
 -		}}
 -	}
 -
  	macro_rules! expect_forward {
  		($node: expr) => {{
  			let mut events = $node.node.get_and_clear_pending_msg_events();
@@@ -1919,10 -1967,10 +1919,10 @@@
  
  	// attempt to send amt_msat > their_max_htlc_value_in_flight_msat
  	{
 -		let (mut route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_0);
 +		let (mut route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], recv_value_0);
  		route.paths[0].last_mut().unwrap().fee_msat += 1;
  		assert!(route.paths[0].iter().rev().skip(1).all(|h| h.fee_msat == feemsat));
 -		unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
 +		unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)), true, APIError::ChannelUnavailable { ref err },
  			assert!(regex::Regex::new(r"Cannot send value that would put us over the max HTLC value in flight our peer will accept \(\d+\)").unwrap().is_match(err)));
  		assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  		nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us over the max HTLC value in flight our peer will accept".to_string(), 1);
@@@ -1940,7 -1988,7 +1940,7 @@@
  		if stat01.value_to_self_msat < stat01.channel_reserve_msat + commit_tx_fee_all_htlcs + ensure_htlc_amounts_above_dust_buffer + amt_msat {
  			break;
  		}
 -		send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0, recv_value_0);
 +		send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0);
  
  		let (stat01_, stat11_, stat12_, stat22_) = (
  			get_channel_value_stat!(nodes[0], chan_1.2),
@@@ -1971,9 -2019,9 +1971,9 @@@
  	let recv_value_1 = (stat01.value_to_self_msat - stat01.channel_reserve_msat - total_fee_msat - commit_tx_fee_2_htlcs)/2;
  	let amt_msat_1 = recv_value_1 + total_fee_msat;
  
 -	let (route_1, our_payment_hash_1, our_payment_preimage_1) = get_route_and_payment_hash!(recv_value_1);
 +	let (route_1, our_payment_hash_1, our_payment_preimage_1, our_payment_secret_1) = get_route_and_payment_hash!(nodes[0], nodes[2], recv_value_1);
  	let payment_event_1 = {
 -		nodes[0].node.send_payment(&route_1, our_payment_hash_1, &None).unwrap();
 +		nodes[0].node.send_payment(&route_1, our_payment_hash_1, &Some(our_payment_secret_1)).unwrap();
  		check_added_monitors!(nodes[0], 1);
  
  		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
@@@ -1985,8 -2033,8 +1985,8 @@@
  	// channel reserve test with htlc pending output > 0
  	let recv_value_2 = stat01.value_to_self_msat - amt_msat_1 - stat01.channel_reserve_msat - total_fee_msat - commit_tx_fee_2_htlcs;
  	{
 -		let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_2 + 1);
 -		unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
 +		let (route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], recv_value_2 + 1);
 +		unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)), true, APIError::ChannelUnavailable { ref err },
  			assert!(regex::Regex::new(r"Cannot send value that would put our balance under counterparty-announced channel reserve value \(\d+\)").unwrap().is_match(err)));
  		assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  	}
@@@ -2002,25 -2050,25 +2002,25 @@@
  	}
  
  	// now see if they go through on both sides
 -	let (route_21, our_payment_hash_21, our_payment_preimage_21) = get_route_and_payment_hash!(recv_value_21);
 +	let (route_21, our_payment_hash_21, our_payment_preimage_21, our_payment_secret_21) = get_route_and_payment_hash!(nodes[0], nodes[2], recv_value_21);
  	// but this will stuck in the holding cell
 -	nodes[0].node.send_payment(&route_21, our_payment_hash_21, &None).unwrap();
 +	nodes[0].node.send_payment(&route_21, our_payment_hash_21, &Some(our_payment_secret_21)).unwrap();
  	check_added_monitors!(nodes[0], 0);
  	let events = nodes[0].node.get_and_clear_pending_events();
  	assert_eq!(events.len(), 0);
  
  	// test with outbound holding cell amount > 0
  	{
 -		let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_22+1);
 -		unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
 +		let (route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], recv_value_22+1);
 +		unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)), true, APIError::ChannelUnavailable { ref err },
  			assert!(regex::Regex::new(r"Cannot send value that would put our balance under counterparty-announced channel reserve value \(\d+\)").unwrap().is_match(err)));
  		assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  		nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put our balance under counterparty-announced channel reserve value".to_string(), 2);
  	}
  
 -	let (route_22, our_payment_hash_22, our_payment_preimage_22) = get_route_and_payment_hash!(recv_value_22);
 +	let (route_22, our_payment_hash_22, our_payment_preimage_22, our_payment_secret_22) = get_route_and_payment_hash!(nodes[0], nodes[2], recv_value_22);
  	// this will also stuck in the holding cell
 -	nodes[0].node.send_payment(&route_22, our_payment_hash_22, &None).unwrap();
 +	nodes[0].node.send_payment(&route_22, our_payment_hash_22, &Some(our_payment_secret_22)).unwrap();
  	check_added_monitors!(nodes[0], 0);
  	assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
  	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
@@@ -2051,7 -2099,7 +2051,7 @@@
  	commitment_signed_dance!(nodes[2], nodes[1], payment_event_11.commitment_msg, false);
  
  	expect_pending_htlcs_forwardable!(nodes[2]);
 -	expect_payment_received!(nodes[2], our_payment_hash_1, recv_value_1);
 +	expect_payment_received!(nodes[2], our_payment_hash_1, our_payment_secret_1, recv_value_1);
  
  	// flush the htlcs in the holding cell
  	assert_eq!(commitment_update_2.update_add_htlcs.len(), 2);
@@@ -2071,31 -2119,29 +2071,31 @@@
  	let events = nodes[2].node.get_and_clear_pending_events();
  	assert_eq!(events.len(), 2);
  	match events[0] {
 -		Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
 +		Event::PaymentReceived { ref payment_hash, ref payment_preimage, ref payment_secret, amt, user_payment_id: _ } => {
  			assert_eq!(our_payment_hash_21, *payment_hash);
 -			assert_eq!(*payment_secret, None);
 +			assert!(payment_preimage.is_none());
 +			assert_eq!(our_payment_secret_21, *payment_secret);
  			assert_eq!(recv_value_21, amt);
  		},
  		_ => panic!("Unexpected event"),
  	}
  	match events[1] {
 -		Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
 +		Event::PaymentReceived { ref payment_hash, ref payment_preimage, ref payment_secret, amt, user_payment_id: _ } => {
  			assert_eq!(our_payment_hash_22, *payment_hash);
 -			assert_eq!(None, *payment_secret);
 +			assert!(payment_preimage.is_none());
 +			assert_eq!(our_payment_secret_22, *payment_secret);
  			assert_eq!(recv_value_22, amt);
  		},
  		_ => panic!("Unexpected event"),
  	}
  
 -	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_1, recv_value_1);
 -	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21, recv_value_21);
 -	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22, recv_value_22);
 +	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_1);
 +	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21);
 +	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22);
  
  	let commit_tx_fee_0_htlcs = 2*commit_tx_fee_msat(feerate, 1);
  	let recv_value_3 = commit_tx_fee_2_htlcs - commit_tx_fee_0_htlcs - total_fee_msat;
 -	send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_3, recv_value_3);
 +	send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_3);
  
  	let commit_tx_fee_1_htlc = 2*commit_tx_fee_msat(feerate, 1 + 1);
  	let expected_value_to_self = stat01.value_to_self_msat - (recv_value_1 + total_fee_msat) - (recv_value_21 + total_fee_msat) - (recv_value_22 + total_fee_msat) - (recv_value_3 + total_fee_msat);
@@@ -2140,15 -2186,15 +2140,15 @@@ fn channel_reserve_in_flight_removes() 
  
  	let b_chan_values = get_channel_value_stat!(nodes[1], chan_1.2);
  	// Route the first two HTLCs.
 -	let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000);
 -	let (payment_preimage_2, _) = route_payment(&nodes[0], &[&nodes[1]], 20000);
 +	let (payment_preimage_1, _, _) = route_payment(&nodes[0], &[&nodes[1]], b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000);
 +	let (payment_preimage_2, _, _) = route_payment(&nodes[0], &[&nodes[1]], 20000);
  
  	// Start routing the third HTLC (this is just used to get everyone in the right state).
 -	let (payment_preimage_3, payment_hash_3) = get_payment_preimage_hash!(nodes[0]);
 +	let (payment_preimage_3, payment_hash_3, payment_secret_3) = get_payment_preimage_hash!(nodes[1]);
  	let send_1 = {
  		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap();
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[0].node.send_payment(&route, payment_hash_3, &Some(payment_secret_3)).unwrap();
  		check_added_monitors!(nodes[0], 1);
  		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
  		assert_eq!(events.len(), 1);
@@@ -2157,13 -2203,13 +2157,13 @@@
  
  	// Now claim both of the first two HTLCs on B's end, putting B in AwaitingRAA and generating an
  	// initial fulfill/CS.
 -	assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000));
 +	assert!(nodes[1].node.claim_funds(payment_preimage_1));
  	check_added_monitors!(nodes[1], 1);
  	let bs_removes = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
  
  	// This claim goes in B's holding cell, allowing us to have a pending B->A RAA which does not
  	// remove the second HTLC when we send the HTLC back from B to A.
 -	assert!(nodes[1].node.claim_funds(payment_preimage_2, &None, 20000));
 +	assert!(nodes[1].node.claim_funds(payment_preimage_2));
  	check_added_monitors!(nodes[1], 1);
  	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
  
@@@ -2207,7 -2253,7 +2207,7 @@@
  	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
  
  	expect_pending_htlcs_forwardable!(nodes[1]);
 -	expect_payment_received!(nodes[1], payment_hash_3, 100000);
 +	expect_payment_received!(nodes[1], payment_hash_3, payment_secret_3, 100000);
  
  	// Note that as this RAA was generated before the delivery of the update_fulfill it shouldn't
  	// resolve the second HTLC from A's point of view.
@@@ -2217,11 -2263,11 +2217,11 @@@
  
  	// Now that B doesn't have the second RAA anymore, but A still does, send a payment from B back
  	// to A to ensure that A doesn't count the almost-removed HTLC in update_add processing.
 -	let (payment_preimage_4, payment_hash_4) = get_payment_preimage_hash!(nodes[1]);
 +	let (payment_preimage_4, payment_hash_4, payment_secret_4) = get_payment_preimage_hash!(nodes[0]);
  	let send_2 = {
  		let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, None, &[], 10000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[1].node.send_payment(&route, payment_hash_4, &None).unwrap();
 +		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 10000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[1].node.send_payment(&route, payment_hash_4, &Some(payment_secret_4)).unwrap();
  		check_added_monitors!(nodes[1], 1);
  		let mut events = nodes[1].node.get_and_clear_pending_msg_events();
  		assert_eq!(events.len(), 1);
@@@ -2254,10 -2300,10 +2254,10 @@@
  	check_added_monitors!(nodes[0], 1);
  
  	expect_pending_htlcs_forwardable!(nodes[0]);
 -	expect_payment_received!(nodes[0], payment_hash_4, 10000);
 +	expect_payment_received!(nodes[0], payment_hash_4, payment_secret_4, 10000);
  
 -	claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4, 10_000);
 -	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 100_000);
 +	claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4);
 +	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3);
  }
  
  #[test]
@@@ -2283,10 -2329,10 +2283,10 @@@ fn channel_monitor_network_test() 
  	connect_blocks(&nodes[4], 4*CHAN_CONFIRM_DEPTH + 1 - nodes[4].best_block_info().1);
  
  	// Rebalance the network a bit by relaying one payment through all the channels...
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
  
  	// Simple case with no pending HTLCs:
  	nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), true);
@@@ -2321,9 -2367,9 +2321,9 @@@
  	assert_eq!(nodes[2].node.list_channels().len(), 1);
  
  	macro_rules! claim_funds {
 -		($node: expr, $prev_node: expr, $preimage: expr, $amount: expr) => {
 +		($node: expr, $prev_node: expr, $preimage: expr) => {
  			{
 -				assert!($node.node.claim_funds($preimage, &None, $amount));
 +				assert!($node.node.claim_funds($preimage));
  				check_added_monitors!($node, 1);
  
  				let events = $node.node.get_and_clear_pending_msg_events();
@@@ -2351,7 -2397,7 +2351,7 @@@
  		node2_commitment_txid = node_txn[0].txid();
  
  		// Claim the payment on nodes[3], giving it knowledge of the preimage
 -		claim_funds!(nodes[3], nodes[2], payment_preimage_1, 3_000_000);
 +		claim_funds!(nodes[3], nodes[2], payment_preimage_1);
  		mine_transaction(&nodes[3], &node_txn[0]);
  		check_added_monitors!(nodes[3], 1);
  		check_preimage_claim(&nodes[3], &node_txn);
@@@ -2400,7 -2446,7 +2400,7 @@@
  		let node_txn = test_txn_broadcast(&nodes[3], &chan_4, None, HTLCType::TIMEOUT);
  
  		// Claim the payment on nodes[4], giving it knowledge of the preimage
 -		claim_funds!(nodes[4], nodes[3], payment_preimage_2, 3_000_000);
 +		claim_funds!(nodes[4], nodes[3], payment_preimage_2);
  
  		connect_blocks(&nodes[4], TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + 2);
  		let events = nodes[4].node.get_and_clear_pending_msg_events();
@@@ -2465,7 -2511,7 +2465,7 @@@ fn test_justice_tx() 
  	assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
  	assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
  	// Revoke the old state
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3);
  
  	{
  		mine_transaction(&nodes[1], &revoked_local_txn[0]);
@@@ -2511,7 -2557,7 +2511,7 @@@
  	assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_6.3.txid());
  	assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to A are present
  	// Revoke the old state
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4);
  	{
  		mine_transaction(&nodes[0], &revoked_local_txn[0]);
  		{
@@@ -2551,7 -2597,7 +2551,7 @@@ fn revoked_output_claim() 
  	// Only output is the full channel value back to nodes[0]:
  	assert_eq!(revoked_local_txn[0].output.len(), 1);
  	// Send a payment through, updating everyone's latest commitment txn
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000, 5_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000);
  
  	// Inform nodes[1] that nodes[0] broadcast a stale tx
  	mine_transaction(&nodes[1], &revoked_local_txn[0]);
@@@ -2581,10 -2627,10 +2581,10 @@@ fn claim_htlc_outputs_shared_tx() 
  	let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
  	// Rebalance the network to generate htlc in the two directions
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
  	// node[0] is gonna to revoke an old state thus node[1] should be able to claim both offered/received HTLC outputs on top of commitment tx
  	let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
 -	let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
 +	let (_payment_preimage_2, payment_hash_2, _) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
  
  	// Get the will-be-revoked local txn from node[0]
  	let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
@@@ -2597,7 -2643,7 +2597,7 @@@
  	check_spends!(revoked_local_txn[1], revoked_local_txn[0]);
  
  	//Revoke the old state
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
  
  	{
  		mine_transaction(&nodes[0], &revoked_local_txn[0]);
@@@ -2650,17 -2696,17 +2650,17 @@@ fn claim_htlc_outputs_single_tx() 
  	let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
  	// Rebalance the network to generate htlc in the two directions
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
  	// node[0] is gonna to revoke an old state thus node[1] should be able to claim both offered/received HTLC outputs on top of commitment tx, but this
  	// time as two different claim transactions as we're gonna to timeout htlc with given a high current height
  	let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
 -	let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
 +	let (_payment_preimage_2, payment_hash_2, _payment_secret_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
  
  	// Get the will-be-revoked local txn from node[0]
  	let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
  
  	//Revoke the old state
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
  
  	{
  		confirm_transaction_at(&nodes[0], &revoked_local_txn[0], 100);
@@@ -2736,19 -2782,19 +2736,19 @@@ fn test_htlc_on_chain_success() 
  	let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
  	// Rebalance the network a bit by relaying one payment through all the channels...
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
  
 -	let (our_payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
 -	let (our_payment_preimage_2, _payment_hash_2) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
 +	let (our_payment_preimage, _payment_hash, _payment_secret) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
 +	let (our_payment_preimage_2, _payment_hash_2, _payment_secret_2) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
  
  	// Broadcast legit commitment tx from C on B's chain
  	// Broadcast HTLC Success transaction by C on received output from C's commitment tx on B's chain
  	let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
  	assert_eq!(commitment_tx.len(), 1);
  	check_spends!(commitment_tx[0], chan_2.3);
 -	nodes[2].node.claim_funds(our_payment_preimage, &None, 3_000_000);
 -	nodes[2].node.claim_funds(our_payment_preimage_2, &None, 3_000_000);
 +	nodes[2].node.claim_funds(our_payment_preimage);
 +	nodes[2].node.claim_funds(our_payment_preimage_2);
  	check_added_monitors!(nodes[2], 2);
  	let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
  	assert!(updates.update_add_htlcs.is_empty());
@@@ -2917,15 -2963,15 +2917,15 @@@ fn do_test_htlc_on_chain_timeout(connec
  	let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
  	// Rebalance the network a bit by relaying one payment thorugh all the channels...
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
  
 -	let (_payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
 +	let (_payment_preimage, payment_hash, _payment_secret) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
  
  	// Broadcast legit commitment tx from C on B's chain
  	let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
  	check_spends!(commitment_tx[0], chan_2.3);
 -	nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
 +	nodes[2].node.fail_htlc_backwards(&payment_hash);
  	check_added_monitors!(nodes[2], 0);
  	expect_pending_htlcs_forwardable!(nodes[2]);
  	check_added_monitors!(nodes[2], 1);
@@@ -3045,13 -3091,13 +3045,13 @@@ fn test_simple_commitment_revoked_fail_
  	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  	let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
 -	let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
 +	let (payment_preimage, _payment_hash, _payment_secret) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
  	// Get the will-be-revoked local txn from nodes[2]
  	let revoked_local_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
  	// Revoke the old state
 -	claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, 3_000_000);
 +	claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
  
 -	let (_, payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
 +	let (_, payment_hash, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
  
  	mine_transaction(&nodes[1], &revoked_local_txn[0]);
  	connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
@@@ -3110,12 -3156,12 +3110,12 @@@ fn do_test_commitment_revoked_fail_back
  	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  	let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
 -	let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], if no_to_remote { 10_000 } else { 3_000_000 });
 +	let (payment_preimage, _payment_hash, _payment_secret) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], if no_to_remote { 10_000 } else { 3_000_000 });
  	// Get the will-be-revoked local txn from nodes[2]
  	let revoked_local_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
  	assert_eq!(revoked_local_txn[0].output.len(), if no_to_remote { 1 } else { 2 });
  	// Revoke the old state
 -	claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, if no_to_remote { 10_000 } else { 3_000_000});
 +	claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
  
  	let value = if use_dust {
  		// The dust limit applied to HTLC outputs considers the fee of the HTLC transaction as
@@@ -3123,11 -3169,11 +3123,11 @@@
  		nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().holder_dust_limit_satoshis * 1000
  	} else { 3000000 };
  
 -	let (_, first_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
 -	let (_, second_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
 -	let (_, third_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
 +	let (_, first_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
 +	let (_, second_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
 +	let (_, third_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
  
 -	assert!(nodes[2].node.fail_htlc_backwards(&first_payment_hash, &None));
 +	assert!(nodes[2].node.fail_htlc_backwards(&first_payment_hash));
  	expect_pending_htlcs_forwardable!(nodes[2]);
  	check_added_monitors!(nodes[2], 1);
  	let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
@@@ -3140,7 -3186,7 +3140,7 @@@
  	let bs_raa = commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false, true, false, true);
  	// Drop the last RAA from 3 -> 2
  
 -	assert!(nodes[2].node.fail_htlc_backwards(&second_payment_hash, &None));
 +	assert!(nodes[2].node.fail_htlc_backwards(&second_payment_hash));
  	expect_pending_htlcs_forwardable!(nodes[2]);
  	check_added_monitors!(nodes[2], 1);
  	let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
@@@ -3157,7 -3203,7 +3157,7 @@@
  	nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
  	check_added_monitors!(nodes[2], 1);
  
 -	assert!(nodes[2].node.fail_htlc_backwards(&third_payment_hash, &None));
 +	assert!(nodes[2].node.fail_htlc_backwards(&third_payment_hash));
  	expect_pending_htlcs_forwardable!(nodes[2]);
  	check_added_monitors!(nodes[2], 1);
  	let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
@@@ -3178,11 -3224,11 +3178,11 @@@
  
  	// Add a fourth HTLC, this one will get sequestered away in nodes[1]'s holding cell waiting
  	// on nodes[2]'s RAA.
 -	let (_, fourth_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, fourth_payment_hash, fourth_payment_secret) = get_payment_preimage_hash!(nodes[2]);
  	let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
  	let logger = test_utils::TestLogger::new();
 -	let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[1].node.send_payment(&route, fourth_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[1].node.send_payment(&route, fourth_payment_hash, &Some(fourth_payment_secret)).unwrap();
  	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
  	assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
  	check_added_monitors!(nodes[1], 0);
@@@ -3331,10 -3377,10 +3331,10 @@@ fn fail_backward_pending_htlc_upon_chan
  
  	// Alice -> Bob: Route a payment but without Bob sending revoke_and_ack.
  	{
 -		let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +		let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[1]);
  		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[0].node.send_payment(&route, payment_hash, &None).unwrap();
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[0].node.send_payment(&route, payment_hash, &Some(payment_secret)).unwrap();
  		check_added_monitors!(nodes[0], 1);
  
  		let payment_event = {
@@@ -3347,11 -3393,11 +3347,11 @@@
  	}
  
  	// Alice -> Bob: Route another payment but now Alice waits for Bob's earlier revoke_and_ack.
 -	let (_, failed_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, failed_payment_hash, failed_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	{
  		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[0].node.send_payment(&route, failed_payment_hash, &None).unwrap();
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[0].node.send_payment(&route, failed_payment_hash, &Some(failed_payment_secret)).unwrap();
  		check_added_monitors!(nodes[0], 0);
  
  		assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
@@@ -3359,14 -3405,14 +3359,14 @@@
  
  	// Alice <- Bob: Send a malformed update_add_htlc so Alice fails the channel.
  	{
 -		let (_, payment_hash) = get_payment_preimage_hash!(nodes[1]);
 +		let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[0]);
  
  		let secp_ctx = Secp256k1::new();
  		let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
  		let current_height = nodes[1].node.best_block.read().unwrap().height() + 1;
  		let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap();
 -		let (onion_payloads, _amount_msat, cltv_expiry) = onion_utils::build_onion_payloads(&route.paths[0], 50_000, &None, current_height).unwrap();
 +		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap();
 +		let (onion_payloads, _amount_msat, cltv_expiry) = onion_utils::build_onion_payloads(&route.paths[0], 50_000, &Some(payment_secret), current_height).unwrap();
  		let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
  		let onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
  
@@@ -3428,12 -3474,12 +3428,12 @@@ fn test_force_close_fail_back() 
  	create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (our_payment_preimage, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[2]);
  
  	let mut payment_event = {
  		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &Vec::new(), 1000000, 42, &logger).unwrap();
 -		nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 1000000, 42, &logger).unwrap();
 +		nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  		check_added_monitors!(nodes[0], 1);
  
  		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
@@@ -3513,7 -3559,7 +3513,7 @@@ fn test_simple_peer_disconnect() 
  	let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
  	let payment_hash_2 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
  	fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_2);
 -	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1, 1_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1);
  
  	nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
  	nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
@@@ -3527,7 -3573,7 +3527,7 @@@
  	nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
  	nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
  
 -	claim_payment_along_route(&nodes[0], &vec!(&nodes[1], &nodes[2]), true, payment_preimage_3, 1_000_000);
 +	claim_payment_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], true, payment_preimage_3);
  	fail_payment_along_route(&nodes[0], &[&nodes[1], &nodes[2]], true, payment_hash_5);
  
  	reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (1, 0), (1, 0), (false, false));
@@@ -3549,7 -3595,7 +3549,7 @@@
  		}
  	}
  
 -	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4, 1_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4);
  	fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_6);
  }
  
@@@ -3566,15 -3612,15 +3566,15 @@@ fn do_test_drop_messages_peer_disconnec
  		create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  	}
  
 -	let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
 +	let (payment_preimage_1, payment_hash_1, payment_secret_1) = get_payment_preimage_hash!(nodes[1]);
  
  	let logger = test_utils::TestLogger::new();
  	let payment_event = {
  		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
  		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(),
 -			&nodes[1].node.get_our_node_id(), None, Some(&nodes[0].node.list_usable_channels().iter().collect::<Vec<_>>()),
 +			&nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), Some(&nodes[0].node.list_usable_channels().iter().collect::<Vec<_>>()),
  			&Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap();
 +		nodes[0].node.send_payment(&route, payment_hash_1, &Some(payment_secret_1)).unwrap();
  		check_added_monitors!(nodes[0], 1);
  
  		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
@@@ -3649,16 -3695,15 +3649,16 @@@
  	let events_2 = nodes[1].node.get_and_clear_pending_events();
  	assert_eq!(events_2.len(), 1);
  	match events_2[0] {
 -		Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
 +		Event::PaymentReceived { ref payment_hash, ref payment_preimage, ref payment_secret, amt, user_payment_id: _ } => {
  			assert_eq!(payment_hash_1, *payment_hash);
 -			assert_eq!(*payment_secret, None);
 +			assert!(payment_preimage.is_none());
 +			assert_eq!(payment_secret_1, *payment_secret);
  			assert_eq!(amt, 1000000);
  		},
  		_ => panic!("Unexpected event"),
  	}
  
 -	nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000);
 +	nodes[1].node.claim_funds(payment_preimage_1);
  	check_added_monitors!(nodes[1], 1);
  
  	let events_3 = nodes[1].node.get_and_clear_pending_msg_events();
@@@ -3750,10 -3795,10 +3750,10 @@@
  	// Channel should still work fine...
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
  	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(),
 -		&nodes[1].node.get_our_node_id(), None, Some(&nodes[0].node.list_usable_channels().iter().collect::<Vec<_>>()),
 +		&nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), Some(&nodes[0].node.list_usable_channels().iter().collect::<Vec<_>>()),
  		&Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
  	let payment_preimage_2 = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000).0;
 -	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
 +	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
  }
  
  #[test]
@@@ -3852,9 -3897,9 +3852,9 @@@ fn test_funding_peer_disconnect() 
  
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
  	let logger = test_utils::TestLogger::new();
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	let (payment_preimage, _) = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000);
 -	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	let (payment_preimage, _, _) = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000);
 +	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
  }
  
  #[test]
@@@ -3868,13 -3913,13 +3868,13 @@@ fn test_drop_messages_peer_disconnect_d
  	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 +	let (payment_preimage_1, _, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
  
  	// Now try to send a second payment which will fail to send
 -	let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
 +	let (payment_preimage_2, payment_hash_2, payment_secret_2) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, payment_hash_2, &Some(payment_secret_2)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  
  	let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
@@@ -3884,7 -3929,7 +3884,7 @@@
  		_ => panic!("Unexpected event"),
  	}
  
 -	assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000));
 +	assert!(nodes[1].node.claim_funds(payment_preimage_1));
  	check_added_monitors!(nodes[1], 1);
  
  	let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
@@@ -3987,10 -4032,9 +3987,10 @@@
  	let events_5 = nodes[1].node.get_and_clear_pending_events();
  	assert_eq!(events_5.len(), 1);
  	match events_5[0] {
 -		Event::PaymentReceived { ref payment_hash, ref payment_secret, amt: _ } => {
 +		Event::PaymentReceived { ref payment_hash, ref payment_preimage, ref payment_secret, amt: _, user_payment_id: _ } => {
  			assert_eq!(payment_hash_2, *payment_hash);
 -			assert_eq!(*payment_secret, None);
 +			assert!(payment_preimage.is_none());
 +			assert_eq!(payment_secret_2, *payment_secret);
  		},
  		_ => panic!("Unexpected event"),
  	}
@@@ -3999,7 -4043,7 +3999,7 @@@
  	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  	check_added_monitors!(nodes[0], 1);
  
 -	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
 +	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
  }
  
  fn do_test_htlc_timeout(send_partial_mpp: bool) {
@@@ -4015,8 -4059,9 +4015,8 @@@
  
  	let our_payment_hash = if send_partial_mpp {
  		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -		let (_, our_payment_hash) = get_payment_preimage_hash!(&nodes[0]);
 -		let payment_secret = PaymentSecret([0xdb; 32]);
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +		let (_, our_payment_hash, payment_secret) = get_payment_preimage_hash!(&nodes[1]);
  		// Use the utility function send_payment_along_path to send the payment with MPP data which
  		// indicates there are more HTLCs coming.
  		let cur_height = CHAN_CONFIRM_DEPTH + 1; // route_payment calls send_payment, which adds 1 to the current height. So we do the same here to match.
@@@ -4026,7 -4071,7 +4026,7 @@@
  		assert_eq!(events.len(), 1);
  		// Now do the relevant commitment_signed/RAA dances along the path, noting that the final
  		// hop should *not* yet generate any PaymentReceived event(s).
 -		pass_along_path(&nodes[0], &[&nodes[1]], 100000, our_payment_hash, Some(payment_secret), events.drain(..).next().unwrap(), false);
 +		pass_along_path(&nodes[0], &[&nodes[1]], 100000, our_payment_hash, payment_secret, events.drain(..).next().unwrap(), false);
  		our_payment_hash
  	} else {
  		route_payment(&nodes[0], &[&nodes[1]], 100000).1
@@@ -4084,21 -4129,21 +4084,21 @@@ fn do_test_holding_cell_htlc_add_timeou
  	let logger = test_utils::TestLogger::new();
  
  	// Route a first payment to get the 1 -> 2 channel in awaiting_raa...
 -	let (_, first_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, first_payment_hash, first_payment_secret) = get_payment_preimage_hash!(nodes[2]);
  	{
  		let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[1].node.send_payment(&route, first_payment_hash, &None).unwrap();
 +		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[1].node.send_payment(&route, first_payment_hash, &Some(first_payment_secret)).unwrap();
  	}
  	assert_eq!(nodes[1].node.get_and_clear_pending_msg_events().len(), 1);
  	check_added_monitors!(nodes[1], 1);
  
  	// Now attempt to route a second payment, which should be placed in the holding cell
 -	let (_, second_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, second_payment_hash, second_payment_secret) = get_payment_preimage_hash!(nodes[2]);
  	if forwarded_htlc {
  		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[0].node.send_payment(&route, second_payment_hash, &None).unwrap();
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[0].node.send_payment(&route, second_payment_hash, &Some(first_payment_secret)).unwrap();
  		check_added_monitors!(nodes[0], 1);
  		let payment_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
  		nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
@@@ -4107,8 -4152,8 +4107,8 @@@
  		check_added_monitors!(nodes[1], 0);
  	} else {
  		let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[1].node.send_payment(&route, second_payment_hash, &None).unwrap();
 +		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[1].node.send_payment(&route, second_payment_hash, &Some(second_payment_secret)).unwrap();
  		check_added_monitors!(nodes[1], 0);
  	}
  
@@@ -4298,7 -4343,7 +4298,7 @@@ fn test_no_txn_manager_serialize_deseri
  		node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
  	}
  
 -	send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
 +	send_payment(&nodes[0], &[&nodes[1]], 1000000);
  }
  
  #[test]
@@@ -4417,7 -4462,7 +4417,7 @@@ fn test_manager_serialize_deserialize_e
  		node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
  	}
  
 -	send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
 +	send_payment(&nodes[0], &[&nodes[1]], 1000000);
  }
  
  #[test]
@@@ -4433,8 -4478,8 +4433,8 @@@ fn test_simple_manager_serialize_deseri
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
 -	let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 -	let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 +	let (our_payment_preimage, _, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 +	let (_, our_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
  
  	nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
  
@@@ -4477,7 -4522,7 +4477,7 @@@
  	reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
  
  	fail_payment(&nodes[0], &[&nodes[1]], our_payment_hash);
 -	claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage, 1_000_000);
 +	claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage);
  }
  
  #[test]
@@@ -4503,7 -4548,7 +4503,7 @@@ fn test_manager_serialize_deserialize_i
  		node_0_stale_monitors_serialized.push(writer.0);
  	}
  
 -	let (our_payment_preimage, _) = route_payment(&nodes[2], &[&nodes[0], &nodes[1]], 1000000);
 +	let (our_payment_preimage, _, _) = route_payment(&nodes[2], &[&nodes[0], &nodes[1]], 1000000);
  
  	// Serialize the ChannelManager here, but the monitor we keep up-to-date
  	let nodes_0_serialized = nodes[0].node.encode();
@@@ -4591,7 -4636,7 +4591,7 @@@
  	reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
  	reconnect_nodes(&nodes[0], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
  	//... and we can even still claim the payment!
 -	claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage, 1_000_000);
 +	claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage);
  
  	nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
  	let reestablish = get_event_msg!(nodes[3], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
@@@ -4707,7 -4752,7 +4707,7 @@@ fn test_claim_on_remote_revoked_sizeabl
  	assert_eq!(revoked_local_txn[0].input.len(), 1);
  	assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
  
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
  	mine_transaction(&nodes[1], &revoked_local_txn[0]);
  	check_closed_broadcast!(nodes[1], true);
  	check_added_monitors!(nodes[1], 1);
@@@ -4740,7 -4785,7 +4740,7 @@@ fn test_static_spendable_outputs_preima
  	assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid());
  
  	// Settle A's commitment tx on B's chain
 -	assert!(nodes[1].node.claim_funds(payment_preimage, &None, 3_000_000));
 +	assert!(nodes[1].node.claim_funds(payment_preimage));
  	check_added_monitors!(nodes[1], 1);
  	mine_transaction(&nodes[1], &commitment_tx[0]);
  	check_added_monitors!(nodes[1], 1);
@@@ -4781,9 -4826,9 +4781,9 @@@ fn test_static_spendable_outputs_timeou
  	let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
  	// Rebalance the network a bit by relaying one payment through all the channels ...
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
  
 -	let (_, our_payment_hash) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000);
 +	let (_, our_payment_hash, _) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000);
  
  	let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
  	assert_eq!(commitment_tx[0].input.len(), 1);
@@@ -4832,7 -4877,7 +4832,7 @@@ fn test_static_spendable_outputs_justic
  	assert_eq!(revoked_local_txn[0].input.len(), 1);
  	assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
  
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
  
  	mine_transaction(&nodes[1], &revoked_local_txn[0]);
  	check_closed_broadcast!(nodes[1], true);
@@@ -4867,7 -4912,7 +4867,7 @@@ fn test_static_spendable_outputs_justic
  	assert_eq!(revoked_local_txn[0].input.len(), 1);
  	assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
  
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
  
  	// A will generate HTLC-Timeout from revoked commitment tx
  	mine_transaction(&nodes[0], &revoked_local_txn[0]);
@@@ -4936,7 -4981,7 +4936,7 @@@ fn test_static_spendable_outputs_justic
  	// The to-be-revoked commitment tx should have one HTLC and one to_remote output
  	assert_eq!(revoked_local_txn[0].output.len(), 2);
  
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
  
  	// B will generate HTLC-Success from revoked commitment tx
  	mine_transaction(&nodes[1], &revoked_local_txn[0]);
@@@ -5015,13 -5060,13 +5015,13 @@@ fn test_onchain_to_onchain_claim() 
  	let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  
  	// Rebalance the network a bit by relaying one payment through all the channels ...
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
 +	send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
  
 -	let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
 +	let (payment_preimage, _payment_hash, _payment_secret) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
  	let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
  	check_spends!(commitment_tx[0], chan_2.3);
 -	nodes[2].node.claim_funds(payment_preimage, &None, 3_000_000);
 +	nodes[2].node.claim_funds(payment_preimage);
  	check_added_monitors!(nodes[2], 1);
  	let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
  	assert!(updates.update_add_htlcs.is_empty());
@@@ -5103,25 -5148,19 +5103,25 @@@
  
  #[test]
  fn test_duplicate_payment_hash_one_failure_one_success() {
 -	// Topology : A --> B --> C
 +	// Topology : A --> B --> C --> D
  	// We route 2 payments with same hash between B and C, one will be timeout, the other successfully claim
 -	let chanmon_cfgs = create_chanmon_cfgs(3);
 -	let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 -	let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 -	let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 +	// Note that because C will refuse to generate two payment secrets for the same payment hash,
 +	// we forward one of the payments onwards to D.
 +	let chanmon_cfgs = create_chanmon_cfgs(4);
 +	let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
 +	let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
 +	let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
  
  	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  	let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 +	create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
  
 -	let (our_payment_preimage, duplicate_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000);
 -	*nodes[0].network_payment_count.borrow_mut() -= 1;
 -	assert_eq!(route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000).1, duplicate_payment_hash);
 +	let (our_payment_preimage, duplicate_payment_hash, _) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000);
 +
 +	let payment_secret = nodes[3].node.create_inbound_payment_for_hash(duplicate_payment_hash, None, 7200, 0).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &nodes[0].net_graph_msg_handler.network_graph.read().unwrap(),
 +		&nodes[3].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 900000, TEST_FINAL_CLTV, nodes[0].logger).unwrap();
 +	send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[2], &nodes[3]]], 900000, duplicate_payment_hash, payment_secret);
  
  	let commitment_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
  	assert_eq!(commitment_txn[0].input.len(), 1);
@@@ -5149,9 -5188,9 +5149,9 @@@
  		htlc_timeout_tx = node_txn[1].clone();
  	}
  
 -	nodes[2].node.claim_funds(our_payment_preimage, &None, 900_000);
 +	nodes[2].node.claim_funds(our_payment_preimage);
  	mine_transaction(&nodes[2], &commitment_txn[0]);
 -	check_added_monitors!(nodes[2], 3);
 +	check_added_monitors!(nodes[2], 2);
  	let events = nodes[2].node.get_and_clear_pending_msg_events();
  	match events[0] {
  		MessageSendEvent::UpdateHTLCs { .. } => {},
@@@ -5240,7 -5279,7 +5240,7 @@@ fn test_dynamic_spendable_outputs_local
  	check_spends!(local_txn[0], chan_1.3);
  
  	// Give B knowledge of preimage to be able to generate a local HTLC-Success Tx
 -	nodes[1].node.claim_funds(payment_preimage, &None, 9_000_000);
 +	nodes[1].node.claim_funds(payment_preimage);
  	check_added_monitors!(nodes[1], 1);
  	mine_transaction(&nodes[1], &local_txn[0]);
  	check_added_monitors!(nodes[1], 1);
@@@ -5299,43 -5338,43 +5299,43 @@@ fn do_test_fail_backwards_unrevoked_rem
  	create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
  
  	// Rebalance and check output sanity...
 -	send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000, 500_000);
 -	send_payment(&nodes[1], &[&nodes[2], &nodes[3], &nodes[5]], 500000, 500_000);
 +	send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000);
 +	send_payment(&nodes[1], &[&nodes[2], &nodes[3], &nodes[5]], 500000);
  	assert_eq!(get_local_commitment_txn!(nodes[3], chan.2)[0].output.len(), 2);
  
  	let ds_dust_limit = nodes[3].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().holder_dust_limit_satoshis;
  	// 0th HTLC:
 -	let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee
 +	let (_, payment_hash_1, _) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee
  	// 1st HTLC:
 -	let (_, payment_hash_2) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee
 +	let (_, payment_hash_2, _) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee
  	let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
  	let our_node_id = &nodes[1].node.get_our_node_id();
 -	let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), None, None, &Vec::new(), ds_dust_limit*1000, TEST_FINAL_CLTV, &logger).unwrap();
 +	let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), ds_dust_limit*1000, TEST_FINAL_CLTV, &logger).unwrap();
  	// 2nd HTLC:
 -	send_along_route_with_hash(&nodes[1], route.clone(), &[&nodes[2], &nodes[3], &nodes[5]], ds_dust_limit*1000, payment_hash_1); // not added < dust limit + HTLC tx fee
 +	send_along_route_with_secret(&nodes[1], route.clone(), &[&[&nodes[2], &nodes[3], &nodes[5]]], ds_dust_limit*1000, payment_hash_1, nodes[5].node.create_inbound_payment_for_hash(payment_hash_1, None, 7200, 0).unwrap()); // not added < dust limit + HTLC tx fee
  	// 3rd HTLC:
 -	send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], ds_dust_limit*1000, payment_hash_2); // not added < dust limit + HTLC tx fee
 +	send_along_route_with_secret(&nodes[1], route, &[&[&nodes[2], &nodes[3], &nodes[5]]], ds_dust_limit*1000, payment_hash_2, nodes[5].node.create_inbound_payment_for_hash(payment_hash_2, None, 7200, 0).unwrap()); // not added < dust limit + HTLC tx fee
  	// 4th HTLC:
 -	let (_, payment_hash_3) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
 +	let (_, payment_hash_3, _) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
  	// 5th HTLC:
 -	let (_, payment_hash_4) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
 -	let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), None, None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	let (_, payment_hash_4, _) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
 +	let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
  	// 6th HTLC:
 -	send_along_route_with_hash(&nodes[1], route.clone(), &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_3);
 +	send_along_route_with_secret(&nodes[1], route.clone(), &[&[&nodes[2], &nodes[3], &nodes[5]]], 1000000, payment_hash_3, nodes[5].node.create_inbound_payment_for_hash(payment_hash_3, None, 7200, 0).unwrap());
  	// 7th HTLC:
 -	send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_4);
 +	send_along_route_with_secret(&nodes[1], route, &[&[&nodes[2], &nodes[3], &nodes[5]]], 1000000, payment_hash_4, nodes[5].node.create_inbound_payment_for_hash(payment_hash_4, None, 7200, 0).unwrap());
  
  	// 8th HTLC:
 -	let (_, payment_hash_5) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
 +	let (_, payment_hash_5, _) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
  	// 9th HTLC:
 -	let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), None, None, &Vec::new(), ds_dust_limit*1000, TEST_FINAL_CLTV, &logger).unwrap();
 -	send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], ds_dust_limit*1000, payment_hash_5); // not added < dust limit + HTLC tx fee
 +	let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), ds_dust_limit*1000, TEST_FINAL_CLTV, &logger).unwrap();
 +	send_along_route_with_secret(&nodes[1], route, &[&[&nodes[2], &nodes[3], &nodes[5]]], ds_dust_limit*1000, payment_hash_5, nodes[5].node.create_inbound_payment_for_hash(payment_hash_5, None, 7200, 0).unwrap()); // not added < dust limit + HTLC tx fee
  
  	// 10th HTLC:
 -	let (_, payment_hash_6) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee
 +	let (_, payment_hash_6, _) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee
  	// 11th HTLC:
 -	let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), None, None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_6);
 +	let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	send_along_route_with_secret(&nodes[1], route, &[&[&nodes[2], &nodes[3], &nodes[5]]], 1000000, payment_hash_6, nodes[5].node.create_inbound_payment_for_hash(payment_hash_6, None, 7200, 0).unwrap());
  
  	// Double-check that six of the new HTLC were added
  	// We now have six HTLCs pending over the dust limit and six HTLCs under the dust limit (ie,
@@@ -5345,10 -5384,10 +5345,10 @@@
  
  	// Now fail back three of the over-dust-limit and three of the under-dust-limit payments in one go.
  	// Fail 0th below-dust, 4th above-dust, 8th above-dust, 10th below-dust HTLCs
 -	assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_1, &None));
 -	assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_3, &None));
 -	assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_5, &None));
 -	assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_6, &None));
 +	assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_1));
 +	assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_3));
 +	assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_5));
 +	assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_6));
  	check_added_monitors!(nodes[4], 0);
  	expect_pending_htlcs_forwardable!(nodes[4]);
  	check_added_monitors!(nodes[4], 1);
@@@ -5361,8 -5400,8 +5361,8 @@@
  	commitment_signed_dance!(nodes[3], nodes[4], four_removes.commitment_signed, false);
  
  	// Fail 3rd below-dust and 7th above-dust HTLCs
 -	assert!(nodes[5].node.fail_htlc_backwards(&payment_hash_2, &None));
 -	assert!(nodes[5].node.fail_htlc_backwards(&payment_hash_4, &None));
 +	assert!(nodes[5].node.fail_htlc_backwards(&payment_hash_2));
 +	assert!(nodes[5].node.fail_htlc_backwards(&payment_hash_4));
  	check_added_monitors!(nodes[5], 0);
  	expect_pending_htlcs_forwardable!(nodes[5]);
  	check_added_monitors!(nodes[5], 1);
@@@ -5538,7 -5577,7 +5538,7 @@@ fn test_dynamic_spendable_outputs_local
  	// Create some initial channels
  	let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
 -	let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
 +	let (_, our_payment_hash, _) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
  	let local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
  	assert_eq!(local_txn[0].input.len(), 1);
  	check_spends!(local_txn[0], chan_1.3);
@@@ -5595,7 -5634,7 +5595,7 @@@ fn test_key_derivation_params() 
  	let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  	assert_ne!(chan_0.3.output[0].script_pubkey, chan_1.3.output[0].script_pubkey);
  
 -	let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
 +	let (_, our_payment_hash, _) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
  	let local_txn_0 = get_local_commitment_txn!(nodes[0], chan_0.2);
  	let local_txn_1 = get_local_commitment_txn!(nodes[0], chan_1.2);
  	assert_eq!(local_txn_1[0].input.len(), 1);
@@@ -5646,7 -5685,7 +5646,7 @@@ fn test_static_output_closing_tx() 
  
  	let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
  	let closing_tx = close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true).2;
  
  	mine_transaction(&nodes[0], &closing_tx);
@@@ -5671,11 -5710,11 +5671,11 @@@ fn do_htlc_claim_local_commitment_only(
  	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  	let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
 -	let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], if use_dust { 50000 } else { 3000000 });
 +	let (our_payment_preimage, _, _) = route_payment(&nodes[0], &[&nodes[1]], if use_dust { 50000 } else { 3000000 });
  
  	// Claim the payment, but don't deliver A's commitment_signed, resulting in the HTLC only being
  	// present in B's local commitment transaction, but none of A's commitment transactions.
 -	assert!(nodes[1].node.claim_funds(our_payment_preimage, &None, if use_dust { 50_000 } else { 3_000_000 }));
 +	assert!(nodes[1].node.claim_funds(our_payment_preimage));
  	check_added_monitors!(nodes[1], 1);
  
  	let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
@@@ -5717,10 -5756,10 +5717,10 @@@ fn do_htlc_claim_current_remote_commitm
  	let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &Vec::new(), if use_dust { 50000 } else { 3000000 }, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), if use_dust { 50000 } else { 3000000 }, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, payment_hash, &Some(payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  
  	let _as_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
@@@ -5753,8 -5792,8 +5753,8 @@@ fn do_htlc_claim_previous_remote_commit
  	// Also optionally test that we *don't* fail the channel in case the commitment transaction was
  	// actually revoked.
  	let htlc_value = if use_dust { 50000 } else { 3000000 };
 -	let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], htlc_value);
 -	assert!(nodes[1].node.fail_htlc_backwards(&our_payment_hash, &None));
 +	let (_, our_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], htlc_value);
 +	assert!(nodes[1].node.fail_htlc_backwards(&our_payment_hash));
  	expect_pending_htlcs_forwardable!(nodes[1]);
  	check_added_monitors!(nodes[1], 1);
  
@@@ -5888,6 -5927,31 +5888,31 @@@ fn bolt2_open_channel_sending_node_chec
  	assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.delayed_payment_basepoint.serialize()).is_ok());
  }
  
+ #[test]
+ fn bolt2_open_channel_sane_dust_limit() {
+ 	let chanmon_cfgs = create_chanmon_cfgs(2);
+ 	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+ 	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
+ 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+ 
+ 	let channel_value_satoshis=1000000;
+ 	let push_msat=10001;
+ 	nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).unwrap();
+ 	let mut node0_to_1_send_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
+ 	node0_to_1_send_open_channel.dust_limit_satoshis = 661;
+ 	node0_to_1_send_open_channel.channel_reserve_satoshis = 100001;
+ 
+ 	nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &node0_to_1_send_open_channel);
+ 	let events = nodes[1].node.get_and_clear_pending_msg_events();
+ 	let err_msg = match events[0] {
+ 		MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id: _ } => {
+ 			msg.clone()
+ 		},
+ 		_ => panic!("Unexpected event"),
+ 	};
+ 	assert_eq!(err_msg.data, "dust_limit_satoshis (661) is greater than the implementation limit (660)");
+ }
+ 
  // Test that if we fail to send an HTLC that is being freed from the holding cell, and the HTLC
  // originated from our node, its failure is surfaced to the user. We trigger this failure to
  // free the HTLC by increasing our fee while the HTLC is in the holding cell such that the HTLC
@@@ -5922,13 -5986,13 +5947,13 @@@ fn test_fail_holding_cell_htlc_upon_fre
  	let feerate = get_feerate!(nodes[0], chan.2);
  
  	// 2* and +1 HTLCs on the commit tx fee calculation for the fee spike reserve.
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let max_can_send = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 1 + 1);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], max_can_send, TEST_FINAL_CLTV, &logger).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], max_can_send, TEST_FINAL_CLTV, &logger).unwrap();
  
  	// Send a payment which passes reserve checks but gets stuck in the holding cell.
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	chan_stat = get_channel_value_stat!(nodes[0], chan.2);
  	assert_eq!(chan_stat.holding_cell_outbound_amount_msat, max_can_send);
  
@@@ -5995,19 -6059,19 +6020,19 @@@ fn test_free_and_fail_holding_cell_htlc
  	let feerate = get_feerate!(nodes[0], chan.2);
  
  	// 2* and +1 HTLCs on the commit tx fee calculation for the fee spike reserve.
 -	let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
 +	let (payment_preimage_1, payment_hash_1, payment_secret_1) = get_payment_preimage_hash!(nodes[1]);
  	let amt_1 = 20000;
 -	let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, payment_hash_2, payment_secret_2) = get_payment_preimage_hash!(nodes[1]);
  	let amt_2 = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 2 + 1) - amt_1;
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route_1 = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], amt_1, TEST_FINAL_CLTV, &logger).unwrap();
 -	let route_2 = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], amt_2, TEST_FINAL_CLTV, &logger).unwrap();
 +	let route_1 = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], amt_1, TEST_FINAL_CLTV, &logger).unwrap();
 +	let route_2 = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], amt_2, TEST_FINAL_CLTV, &logger).unwrap();
  
  	// Send 2 payments which pass reserve checks but get stuck in the holding cell.
 -	nodes[0].node.send_payment(&route_1, payment_hash_1, &None).unwrap();
 +	nodes[0].node.send_payment(&route_1, payment_hash_1, &Some(payment_secret_1)).unwrap();
  	chan_stat = get_channel_value_stat!(nodes[0], chan.2);
  	assert_eq!(chan_stat.holding_cell_outbound_amount_msat, amt_1);
 -	nodes[0].node.send_payment(&route_2, payment_hash_2, &None).unwrap();
 +	nodes[0].node.send_payment(&route_2, payment_hash_2, &Some(payment_secret_2)).unwrap();
  	chan_stat = get_channel_value_stat!(nodes[0], chan.2);
  	assert_eq!(chan_stat.holding_cell_outbound_amount_msat, amt_1 + amt_2);
  
@@@ -6068,7 -6132,7 +6093,7 @@@
  		Event::PaymentReceived { .. } => {},
  		_ => panic!("Unexpected event"),
  	}
 -	nodes[1].node.claim_funds(payment_preimage_1, &None, amt_1);
 +	nodes[1].node.claim_funds(payment_preimage_1);
  	check_added_monitors!(nodes[1], 1);
  	let update_msgs = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
  	nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_msgs.update_fulfill_htlcs[0]);
@@@ -6120,12 -6184,12 +6145,12 @@@ fn test_fail_holding_cell_htlc_upon_fre
  	// Send a payment which passes reserve checks but gets stuck in the holding cell.
  	let feemsat = 239;
  	let total_routing_fee_msat = (nodes.len() - 2) as u64 * feemsat;
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[2]);
  	let max_can_send = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 1 + 1) - total_routing_fee_msat;
  	let payment_event = {
  		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &[], max_can_send, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], max_can_send, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  		check_added_monitors!(nodes[0], 1);
  
  		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
@@@ -6237,13 -6301,13 +6262,13 @@@ fn test_update_add_htlc_bolt2_sender_va
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  	let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
  	let logger = test_utils::TestLogger::new();
 -	let mut route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +	let mut route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
  	route.paths[0][0].fee_msat = 100;
  
 -	unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
 +	unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)), true, APIError::ChannelUnavailable { ref err },
  		assert!(regex::Regex::new(r"Cannot send less than their minimum HTLC value \(\d+\)").unwrap().is_match(err)));
  	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  	nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send less than their minimum HTLC value".to_string(), 1);
@@@ -6257,13 -6321,13 +6282,13 @@@ fn test_update_add_htlc_bolt2_sender_ze
  	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  	let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
  	let logger = test_utils::TestLogger::new();
 -	let mut route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +	let mut route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
  	route.paths[0][0].fee_msat = 0;
 -	unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
 +	unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)), true, APIError::ChannelUnavailable { ref err },
  		assert_eq!(err, "Cannot send 0-msat HTLC"));
  
  	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
@@@ -6279,11 -6343,11 +6304,11 @@@ fn test_update_add_htlc_bolt2_receiver_
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  	let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
  	let logger = test_utils::TestLogger::new();
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  	let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  	updates.update_add_htlcs[0].amount_msat = 0;
@@@ -6305,11 -6369,11 +6330,11 @@@ fn test_update_add_htlc_bolt2_sender_cl
  	let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 0, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 100000000, 500000001, &logger).unwrap();
 -	unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::RouteError { ref err },
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000000, 500000001, &logger).unwrap();
 +	unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)), true, APIError::RouteError { ref err },
  		assert_eq!(err, &"Channel CLTV overflowed?"));
  }
  
@@@ -6327,11 -6391,11 +6352,11 @@@ fn test_update_add_htlc_bolt2_sender_ex
  
  	let logger = test_utils::TestLogger::new();
  	for i in 0..max_accepted_htlcs {
 -		let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +		let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  		let payment_event = {
  			let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -			let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -			nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +			let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +			nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  			check_added_monitors!(nodes[0], 1);
  
  			let mut events = nodes[0].node.get_and_clear_pending_msg_events();
@@@ -6348,12 -6412,12 +6373,12 @@@
  		commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
  
  		expect_pending_htlcs_forwardable!(nodes[1]);
 -		expect_payment_received!(nodes[1], our_payment_hash, 100000);
 +		expect_payment_received!(nodes[1], our_payment_hash, our_payment_secret, 100000);
  	}
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -	unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +	unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)), true, APIError::ChannelUnavailable { ref err },
  		assert!(regex::Regex::new(r"Cannot push more than their max accepted HTLCs \(\d+\)").unwrap().is_match(err)));
  
  	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
@@@ -6371,9 -6435,9 +6396,9 @@@ fn test_update_add_htlc_bolt2_sender_ex
  	let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 0, InitFeatures::known(), InitFeatures::known());
  	let max_in_flight = get_channel_value_stat!(nodes[0], chan.2).counterparty_max_htlc_value_in_flight_msat;
  
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight, max_in_flight);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight);
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	// Manually create a route over our max in flight (which our router normally automatically
  	// limits us to.
  	let route = Route { paths: vec![vec![RouteHop {
@@@ -6381,13 -6445,13 +6406,13 @@@
  	   short_channel_id: nodes[1].node.list_usable_channels()[0].short_channel_id.unwrap(),
  	   fee_msat: max_in_flight + 1, cltv_expiry_delta: TEST_FINAL_CLTV
  	}]] };
 -	unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
 +	unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)), true, APIError::ChannelUnavailable { ref err },
  		assert!(regex::Regex::new(r"Cannot send value that would put us over the max HTLC value in flight our peer will accept \(\d+\)").unwrap().is_match(err)));
  
  	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  	nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us over the max HTLC value in flight our peer will accept".to_string(), 1);
  
 -	send_payment(&nodes[0], &[&nodes[1]], max_in_flight, max_in_flight);
 +	send_payment(&nodes[0], &[&nodes[1]], max_in_flight);
  }
  
  // BOLT 2 Requirements for the Receiver when handling an update_add_htlc message.
@@@ -6406,11 -6470,11 +6431,11 @@@ fn test_update_add_htlc_bolt2_receiver_
  		htlc_minimum_msat = channel.get_holder_htlc_minimum_msat();
  	}
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
  	let logger = test_utils::TestLogger::new();
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], htlc_minimum_msat, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], htlc_minimum_msat, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  	let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  	updates.update_add_htlcs[0].amount_msat = htlc_minimum_msat-1;
@@@ -6438,10 -6502,10 +6463,10 @@@ fn test_update_add_htlc_bolt2_receiver_
  	let commit_tx_fee_outbound = 2 * commit_tx_fee_msat(feerate, 1 + 1);
  
  	let max_can_send = 5000000 - channel_reserve - commit_tx_fee_outbound;
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], max_can_send, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], max_can_send, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  	let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  
@@@ -6468,15 -6532,15 +6493,15 @@@ fn test_update_add_htlc_bolt2_receiver_
  	let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
  
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 3999999, TEST_FINAL_CLTV, &logger).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 3999999, TEST_FINAL_CLTV, &logger).unwrap();
  
  	let cur_height = nodes[0].node.best_block.read().unwrap().height() + 1;
  	let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::signing_only(), &route.paths[0], &session_priv).unwrap();
 -	let (onion_payloads, _htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 3999999, &None, cur_height).unwrap();
 +	let (onion_payloads, _htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 3999999, &Some(our_payment_secret), cur_height).unwrap();
  	let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &our_payment_hash);
  
  	let mut msg = msgs::UpdateAddHTLC {
@@@ -6511,10 -6575,10 +6536,10 @@@ fn test_update_add_htlc_bolt2_receiver_
  	let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  	let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  	updates.update_add_htlcs[0].amount_msat = get_channel_value_stat!(nodes[1], chan.2).counterparty_max_htlc_value_in_flight_msat + 1;
@@@ -6536,10 -6600,10 +6561,10 @@@ fn test_update_add_htlc_bolt2_receiver_
  	let logger = test_utils::TestLogger::new();
  
  	create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  	let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  	updates.update_add_htlcs[0].cltv_expiry = 500000000;
@@@ -6563,10 -6627,10 +6588,10 @@@ fn test_update_add_htlc_bolt2_receiver_
  	let logger = test_utils::TestLogger::new();
  
  	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  	let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  	nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
@@@ -6610,10 -6674,10 +6635,10 @@@ fn test_update_fulfill_htlc_bolt2_updat
  	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  	let logger = test_utils::TestLogger::new();
  	let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 -	let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (our_payment_preimage, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  
  	check_added_monitors!(nodes[0], 1);
  	let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
@@@ -6644,10 -6708,10 +6669,10 @@@ fn test_update_fulfill_htlc_bolt2_updat
  	let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  	let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  	nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
@@@ -6677,10 -6741,10 +6702,10 @@@ fn test_update_fulfill_htlc_bolt2_updat
  	let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  	let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
  	nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
@@@ -6711,7 -6775,7 +6736,7 @@@ fn test_update_fulfill_htlc_bolt2_incor
  
  	let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
  
 -	nodes[1].node.claim_funds(our_payment_preimage, &None, 100_000);
 +	nodes[1].node.claim_funds(our_payment_preimage);
  	check_added_monitors!(nodes[1], 1);
  
  	let events = nodes[1].node.get_and_clear_pending_msg_events();
@@@ -6752,7 -6816,7 +6777,7 @@@ fn test_update_fulfill_htlc_bolt2_wrong
  
  	let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
  
 -	nodes[1].node.claim_funds(our_payment_preimage, &None, 100_000);
 +	nodes[1].node.claim_funds(our_payment_preimage);
  	check_added_monitors!(nodes[1], 1);
  
  	let events = nodes[1].node.get_and_clear_pending_msg_events();
@@@ -6792,10 -6856,10 +6817,10 @@@ fn test_update_fulfill_htlc_bolt2_missi
  	create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 -	nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  	check_added_monitors!(nodes[0], 1);
  
  	let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
@@@ -6842,13 -6906,13 +6867,13 @@@ fn test_update_fulfill_htlc_bolt2_after
  	create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
  	let logger = test_utils::TestLogger::new();
  
 -	let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[2]);
  
  	//First hop
  	let mut payment_event = {
  		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
  		check_added_monitors!(nodes[0], 1);
  		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
  		assert_eq!(events.len(), 1);
@@@ -6924,15 -6988,15 +6949,15 @@@ fn do_test_failure_delay_dust_htlc_loca
  	let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().holder_dust_limit_satoshis;
  
  	// We route 2 dust-HTLCs between A and B
 -	let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
 -	let (_, payment_hash_2) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
 +	let (_, payment_hash_1, _) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
 +	let (_, payment_hash_2, _) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
  	route_payment(&nodes[0], &[&nodes[1]], 1000000);
  
  	// Cache one local commitment tx as previous
  	let as_prev_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
  
  	// Fail one HTLC to prune it in the will-be-latest-local commitment tx
 -	assert!(nodes[1].node.fail_htlc_backwards(&payment_hash_2, &None));
 +	assert!(nodes[1].node.fail_htlc_backwards(&payment_hash_2));
  	check_added_monitors!(nodes[1], 0);
  	expect_pending_htlcs_forwardable!(nodes[1]);
  	check_added_monitors!(nodes[1], 1);
@@@ -7013,16 -7077,16 +7038,16 @@@ fn do_test_sweep_outbound_htlc_failure_
  
  	let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().holder_dust_limit_satoshis;
  
 -	let (_payment_preimage_1, dust_hash) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
 -	let (_payment_preimage_2, non_dust_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 +	let (_payment_preimage_1, dust_hash, _payment_secret_1) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
 +	let (_payment_preimage_2, non_dust_hash, _payment_secret_2) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
  
  	let as_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
  	let bs_commitment_tx = get_local_commitment_txn!(nodes[1], chan.2);
  
  	// We revoked bs_commitment_tx
  	if revoked {
 -		let (payment_preimage_3, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 -		claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 1_000_000);
 +		let (payment_preimage_3, _, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 +		claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3);
  	}
  
  	let mut timeout_tx = Vec::new();
@@@ -7395,8 -7459,8 +7420,8 @@@ fn test_data_loss_protect() 
  	let mut previous_chain_monitor_state = test_utils::TestVecWriter(Vec::new());
  	nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().iter().next().unwrap().1.write(&mut previous_chain_monitor_state).unwrap();
  
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
  
  	nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
  	nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
@@@ -7488,30 -7552,16 +7513,30 @@@ fn test_check_htlc_underpaying() 
  	let chanmon_cfgs = create_chanmon_cfgs(2);
  	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
  	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 -	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 +	let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  
  	// Create some initial channels
  	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  
 -	let (payment_preimage, payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 10_000);
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &nodes[0].net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 10_000, TEST_FINAL_CLTV, nodes[0].logger).unwrap();
 +	let (_, our_payment_hash, _) = get_payment_preimage_hash!(nodes[0]);
 +	let our_payment_secret = nodes[1].node.create_inbound_payment_for_hash(our_payment_hash, Some(100_000), 7200, 0).unwrap();
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
 +	check_added_monitors!(nodes[0], 1);
  
 -	// Node 3 is expecting payment of 100_000 but receive 10_000,
 -	// fail htlc like we didn't know the preimage.
 -	nodes[1].node.claim_funds(payment_preimage, &None, 100_000);
 +	let mut events = nodes[0].node.get_and_clear_pending_msg_events();
 +	assert_eq!(events.len(), 1);
 +	let mut payment_event = SendEvent::from_event(events.pop().unwrap());
 +	nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
 +	commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
 +
 +	// Note that we first have to wait a random delay before processing the receipt of the HTLC,
 +	// and then will wait a second random delay before failing the HTLC back:
 +	expect_pending_htlcs_forwardable!(nodes[1]);
 +	expect_pending_htlcs_forwardable!(nodes[1]);
 +
 +	// Node 3 is expecting payment of 100_000 but received 10_000,
 +	// it should fail htlc like we didn't know the preimage.
  	nodes[1].node.process_pending_htlc_forwards();
  
  	let events = nodes[1].node.get_and_clear_pending_msg_events();
@@@ -7535,7 -7585,8 +7560,7 @@@
  	// 10_000 msat as u64, followed by a height of CHAN_CONFIRM_DEPTH as u32
  	let mut expected_failure_data = byte_utils::be64_to_array(10_000).to_vec();
  	expected_failure_data.extend_from_slice(&byte_utils::be32_to_array(CHAN_CONFIRM_DEPTH));
 -	expect_payment_failed!(nodes[0], payment_hash, true, 0x4000|15, &expected_failure_data[..]);
 -	nodes[1].node.get_and_clear_pending_events();
 +	expect_payment_failed!(nodes[0], our_payment_hash, true, 0x4000|15, &expected_failure_data[..]);
  }
  
  #[test]
@@@ -7615,7 -7666,7 +7640,7 @@@ fn test_bump_penalty_txn_on_revoked_com
  
  	let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
  	let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -	let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, None, &Vec::new(), 3000000, 30, &logger).unwrap();
 +	let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 3000000, 30, &logger).unwrap();
  	send_along_route(&nodes[1], route, &vec!(&nodes[0])[..], 3000000);
  
  	let revoked_txn = get_local_commitment_txn!(nodes[0], chan.2);
@@@ -7636,7 -7687,7 +7661,7 @@@
  	let header_114 = connect_blocks(&nodes[1], 14);
  
  	// Actually revoke tx by claiming a HTLC
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
  	let header = BlockHeader { version: 0x20000000, prev_blockhash: header_114, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
  	connect_block(&nodes[1], &Block { header, txdata: vec![revoked_txn[0].clone()] });
  	check_added_monitors!(nodes[1], 1);
@@@ -7727,7 -7778,7 +7752,7 @@@ fn test_bump_penalty_txn_on_revoked_htl
  	assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
  
  	// Revoke local commitment tx
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
  
  	let header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[1].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
  	// B will generate both revoked HTLC-timeout/HTLC-preimage txn from revoked commitment tx
@@@ -7893,7 -7944,7 +7918,7 @@@ fn test_bump_penalty_txn_on_remote_comm
  	assert_eq!(remote_txn[0].input[0].previous_output.txid, chan.3.txid());
  
  	// Claim a HTLC without revocation (provide B monitor with preimage)
 -	nodes[1].node.claim_funds(payment_preimage, &None, 3_000_000);
 +	nodes[1].node.claim_funds(payment_preimage);
  	mine_transaction(&nodes[1], &remote_txn[0]);
  	check_added_monitors!(nodes[1], 2);
  
@@@ -8030,7 -8081,7 +8055,7 @@@ fn test_bump_txn_sanitize_tracking_maps
  	assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
  
  	// Revoke local commitment tx
 -	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 9_000_000);
 +	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
  
  	// Broadcast set of revoked txn on A
  	connect_blocks(&nodes[0], 52 - CHAN_CONFIRM_DEPTH);
@@@ -8099,6 -8150,31 +8124,6 @@@ fn test_override_0msat_htlc_minimum() 
  	assert_eq!(res.htlc_minimum_msat, 1);
  }
  
 -#[test]
 -fn test_simple_payment_secret() {
 -	// Simple test of sending a payment with a payment_secret present. This does not use any AMP
 -	// features, however.
 -	let chanmon_cfgs = create_chanmon_cfgs(3);
 -	let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 -	let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 -	let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 -
 -	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 -	create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 -	let logger = test_utils::TestLogger::new();
 -
 -	let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
 -	let payment_secret = PaymentSecret([0xdb; 32]);
 -	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 -	send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[2]]], 100000, payment_hash, Some(payment_secret.clone()));
 -	// Claiming with all the correct values but the wrong secret should result in nothing...
 -	assert_eq!(nodes[2].node.claim_funds(payment_preimage, &None, 100_000), false);
 -	assert_eq!(nodes[2].node.claim_funds(payment_preimage, &Some(PaymentSecret([42; 32])), 100_000), false);
 -	// ...but with the right secret we should be able to claim all the way back
 -	claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[2]]], false, payment_preimage, Some(payment_secret.clone()), 100_000);
 -}
 -
  #[test]
  fn test_simple_mpp() {
  	// Simple test of sending a multi-path payment.
@@@ -8113,9 -8189,10 +8138,9 @@@
  	let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
  	let logger = test_utils::TestLogger::new();
  
 -	let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
 -	let payment_secret = PaymentSecret([0xdb; 32]);
 +	let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash!(&nodes[3]);
  	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 -	let mut route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[3].node.get_our_node_id(), None, None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 +	let mut route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[3].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
  	let path = route.paths[0].clone();
  	route.paths.push(path);
  	route.paths[0][0].pubkey = nodes[1].node.get_our_node_id();
@@@ -8124,176 -8201,12 +8149,176 @@@
  	route.paths[1][0].pubkey = nodes[2].node.get_our_node_id();
  	route.paths[1][0].short_channel_id = chan_2_id;
  	route.paths[1][1].short_channel_id = chan_4_id;
 -	send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], 200_000, payment_hash, Some(payment_secret.clone()));
 -	// Claiming with all the correct values but the wrong secret should result in nothing...
 -	assert_eq!(nodes[3].node.claim_funds(payment_preimage, &None, 200_000), false);
 -	assert_eq!(nodes[3].node.claim_funds(payment_preimage, &Some(PaymentSecret([42; 32])), 200_000), false);
 -	// ...but with the right secret we should be able to claim all the way back
 -	claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage, Some(payment_secret), 200_000);
 +	send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], 200_000, payment_hash, payment_secret);
 +	claim_payment_along_route(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage);
 +}
 +
 +#[test]
 +fn test_preimage_storage() {
 +	// Simple test of payment preimage storage allowing no client-side storage to claim payments
 +	let chanmon_cfgs = create_chanmon_cfgs(2);
 +	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 +	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 +	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 +
 +	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
 +
 +	{
 +		let (payment_hash, payment_secret) = nodes[1].node.create_inbound_payment(Some(100_000), 7200, 42);
 +
 +		let logger = test_utils::TestLogger::new();
 +		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100_000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[0].node.send_payment(&route, payment_hash, &Some(payment_secret)).unwrap();
 +		check_added_monitors!(nodes[0], 1);
 +		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
 +		let mut payment_event = SendEvent::from_event(events.pop().unwrap());
 +		nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
 +		commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
 +	}
 +	// Note that after leaving the above scope we have no knowledge of any arguments or return
 +	// values from previous calls.
 +	expect_pending_htlcs_forwardable!(nodes[1]);
 +	let events = nodes[1].node.get_and_clear_pending_events();
 +	assert_eq!(events.len(), 1);
 +	match events[0] {
 +		Event::PaymentReceived { payment_preimage, user_payment_id, .. } => {
 +			assert_eq!(user_payment_id, 42);
 +			claim_payment(&nodes[0], &[&nodes[1]], payment_preimage.unwrap());
 +		},
 +		_ => panic!("Unexpected event"),
 +	}
 +}
 +
 +#[test]
 +fn test_secret_timeout() {
 +	// Simple test of payment secret storage time outs
 +	let chanmon_cfgs = create_chanmon_cfgs(2);
 +	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 +	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 +	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 +
 +	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
 +
 +	let (payment_hash, payment_secret_1) = nodes[1].node.create_inbound_payment(Some(100_000), 2, 0);
 +
 +	// We should fail to register the same payment hash twice, at least until we've connected a
 +	// block with time 7200 + CHAN_CONFIRM_DEPTH + 1.
 +	if let Err(APIError::APIMisuseError { err }) = nodes[1].node.create_inbound_payment_for_hash(payment_hash, Some(100_000), 2, 0) {
 +		assert_eq!(err, "Duplicate payment hash");
 +	} else { panic!(); }
 +	let mut block = Block {
 +		header: BlockHeader {
 +			version: 0x2000000,
 +			prev_blockhash: nodes[1].blocks.borrow().last().unwrap().0.block_hash(),
 +			merkle_root: Default::default(),
 +			time: nodes[1].blocks.borrow().len() as u32 + 7200, bits: 42, nonce: 42 },
 +		txdata: vec![],
 +	};
 +	connect_block(&nodes[1], &block);
 +	if let Err(APIError::APIMisuseError { err }) = nodes[1].node.create_inbound_payment_for_hash(payment_hash, Some(100_000), 2, 0) {
 +		assert_eq!(err, "Duplicate payment hash");
 +	} else { panic!(); }
 +
 +	// If we then connect the second block, we should be able to register the same payment hash
 +	// again with a different user_payment_id (this time getting a new payment secret).
 +	block.header.prev_blockhash = block.header.block_hash();
 +	block.header.time += 1;
 +	connect_block(&nodes[1], &block);
 +	let our_payment_secret = nodes[1].node.create_inbound_payment_for_hash(payment_hash, Some(100_000), 2, 42).unwrap();
 +	assert_ne!(payment_secret_1, our_payment_secret);
 +
 +	{
 +		let logger = test_utils::TestLogger::new();
 +		let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 +		let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100_000, TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[0].node.send_payment(&route, payment_hash, &Some(our_payment_secret)).unwrap();
 +		check_added_monitors!(nodes[0], 1);
 +		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
 +		let mut payment_event = SendEvent::from_event(events.pop().unwrap());
 +		nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
 +		commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
 +	}
 +	// Note that after leaving the above scope we have no knowledge of any arguments or return
 +	// values from previous calls.
 +	expect_pending_htlcs_forwardable!(nodes[1]);
 +	let events = nodes[1].node.get_and_clear_pending_events();
 +	assert_eq!(events.len(), 1);
 +	match events[0] {
 +		Event::PaymentReceived { payment_preimage, payment_secret, user_payment_id, .. } => {
 +			assert!(payment_preimage.is_none());
 +			assert_eq!(user_payment_id, 42);
 +			assert_eq!(payment_secret, our_payment_secret);
 +			// We don't actually have the payment preimage with which to claim this payment!
 +		},
 +		_ => panic!("Unexpected event"),
 +	}
 +}
 +
 +#[test]
 +fn test_bad_secret_hash() {
 +	// Simple test of unregistered payment hash/invalid payment secret handling
 +	let chanmon_cfgs = create_chanmon_cfgs(2);
 +	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 +	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 +	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 +
 +	create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
 +
 +	let random_payment_hash = PaymentHash([42; 32]);
 +	let random_payment_secret = PaymentSecret([43; 32]);
 +	let (our_payment_hash, our_payment_secret) = nodes[1].node.create_inbound_payment(Some(100_000), 2, 0);
 +
 +	let logger = test_utils::TestLogger::new();
 +	let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 +	let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &[], 100_000, TEST_FINAL_CLTV, &logger).unwrap();
 +
 +	// All the below cases should end up being handled exactly identically, so we macro the
 +	// resulting events.
 +	macro_rules! handle_unknown_invalid_payment_data {
 +		() => {
 +			check_added_monitors!(nodes[0], 1);
 +			let mut events = nodes[0].node.get_and_clear_pending_msg_events();
 +			let payment_event = SendEvent::from_event(events.pop().unwrap());
 +			nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
 +			commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
 +
 +			// We have to forward pending HTLCs once to process the receipt of the HTLC and then
 +			// again to process the pending backwards-failure of the HTLC
 +			expect_pending_htlcs_forwardable!(nodes[1]);
 +			expect_pending_htlcs_forwardable!(nodes[1]);
 +			check_added_monitors!(nodes[1], 1);
 +
 +			// We should fail the payment back
 +			let mut events = nodes[1].node.get_and_clear_pending_msg_events();
 +			match events.pop().unwrap() {
 +				MessageSendEvent::UpdateHTLCs { node_id: _, updates: msgs::CommitmentUpdate { update_fail_htlcs, commitment_signed, .. } } => {
 +					nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
 +					commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false);
 +				},
 +				_ => panic!("Unexpected event"),
 +			}
 +		}
 +	}
 +
 +	let expected_error_code = 0x4000|15; // incorrect_or_unknown_payment_details
 +	// Error data is the HTLC value (100,000) and current block height
 +	let expected_error_data = [0, 0, 0, 0, 0, 1, 0x86, 0xa0, 0, 0, 0, CHAN_CONFIRM_DEPTH as u8];
 +
 +	// Send a payment with the right payment hash but the wrong payment secret
 +	nodes[0].node.send_payment(&route, our_payment_hash, &Some(random_payment_secret)).unwrap();
 +	handle_unknown_invalid_payment_data!();
 +	expect_payment_failed!(nodes[0], our_payment_hash, true, expected_error_code, expected_error_data);
 +
 +	// Send a payment with a random payment hash, but the right payment secret
 +	nodes[0].node.send_payment(&route, random_payment_hash, &Some(our_payment_secret)).unwrap();
 +	handle_unknown_invalid_payment_data!();
 +	expect_payment_failed!(nodes[0], random_payment_hash, true, expected_error_code, expected_error_data);
 +
 +	// Send a payment with a random payment hash and random payment secret
 +	nodes[0].node.send_payment(&route, random_payment_hash, &Some(random_payment_secret)).unwrap();
 +	handle_unknown_invalid_payment_data!();
 +	expect_payment_failed!(nodes[0], random_payment_hash, true, expected_error_code, expected_error_data);
  }
  
  #[test]
@@@ -8316,7 -8229,7 +8341,7 @@@ fn test_update_err_monitor_lockdown() 
  	let outpoint = OutPoint { txid: chan_1.3.txid(), index: 0 };
  
  	// Rebalance the network to generate htlc in the two directions
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000, 10_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000);
  
  	// Route a HTLC from node 0 to node 1 (but don't settle)
  	let preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
@@@ -8341,7 -8254,7 +8366,7 @@@
  	watchtower.chain_monitor.block_connected(&Block { header, txdata: vec![] }, 200);
  
  	// Try to update ChannelMonitor
 -	assert!(nodes[1].node.claim_funds(preimage, &None, 9_000_000));
 +	assert!(nodes[1].node.claim_funds(preimage));
  	check_added_monitors!(nodes[1], 1);
  	let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
  	assert_eq!(updates.update_fulfill_htlcs.len(), 1);
@@@ -8375,7 -8288,7 +8400,7 @@@ fn test_concurrent_monitor_claim() 
  	let outpoint = OutPoint { txid: chan_1.3.txid(), index: 0 };
  
  	// Rebalance the network to generate htlc in the two directions
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000, 10_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000);
  
  	// Route a HTLC from node 0 to node 1 (but don't settle)
  	route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
@@@ -8426,11 -8339,11 +8451,11 @@@
  	watchtower_bob.chain_monitor.block_connected(&Block { header, txdata: vec![] }, CHAN_CONFIRM_DEPTH + TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS);
  
  	// Route another payment to generate another update with still previous HTLC pending
 -	let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
 +	let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[0]);
  	{
  		let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 -		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, None, &Vec::new(), 3000000 , TEST_FINAL_CLTV, &logger).unwrap();
 -		nodes[1].node.send_payment(&route, payment_hash, &None).unwrap();
 +		let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 3000000 , TEST_FINAL_CLTV, &logger).unwrap();
 +		nodes[1].node.send_payment(&route, payment_hash, &Some(payment_secret)).unwrap();
  	}
  	check_added_monitors!(nodes[1], 1);
  
@@@ -8528,8 -8441,8 +8553,8 @@@ fn test_htlc_no_detection() 
  	// Create some initial channels
  	let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known());
  
 -	send_payment(&nodes[0], &vec!(&nodes[1])[..], 1_000_000, 1_000_000);
 -	let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 2_000_000);
 +	send_payment(&nodes[0], &vec!(&nodes[1])[..], 1_000_000);
 +	let (_, our_payment_hash, _) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 2_000_000);
  	let local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
  	assert_eq!(local_txn[0].input.len(), 1);
  	assert_eq!(local_txn[0].output.len(), 3);
@@@ -8583,7 -8496,7 +8608,7 @@@ fn do_test_onchain_htlc_settlement_afte
  
  	// Steps (1) and (2):
  	// Send an HTLC Alice --> Bob --> Carol, but Carol doesn't settle the HTLC back.
 -	let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3_000_000);
 +	let (payment_preimage, _payment_hash, _payment_secret) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3_000_000);
  
  	// Check that Alice's commitment transaction now contains an output for this HTLC.
  	let alice_txn = get_local_commitment_txn!(nodes[0], chan_ab.2);
@@@ -8620,7 -8533,7 +8645,7 @@@
  	// Step (5):
  	// Carol then claims the funds and sends an update_fulfill message to Bob, and they go through the
  	// process of removing the HTLC from their commitment transactions.
 -	assert!(nodes[2].node.claim_funds(payment_preimage, &None, 3_000_000));
 +	assert!(nodes[2].node.claim_funds(payment_preimage));
  	check_added_monitors!(nodes[2], 1);
  	let carol_updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
  	assert!(carol_updates.update_add_htlcs.is_empty());
@@@ -8874,7 -8787,7 +8899,7 @@@ fn test_duplicate_chan_id() 
  	let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
  	let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
  	update_nodes_with_chan_announce(&nodes, 0, 1, &announcement, &as_update, &bs_update);
 -	send_payment(&nodes[0], &[&nodes[1]], 8000000, 8_000_000);
 +	send_payment(&nodes[0], &[&nodes[1]], 8000000);
  }
  
  #[test]
diff --combined lightning/src/util/config.rs
index de83f227b,5e902c175..4a66fa37a
--- a/lightning/src/util/config.rs
+++ b/lightning/src/util/config.rs
@@@ -98,22 -98,6 +98,6 @@@ pub struct ChannelHandshakeLimits 
  	///
  	/// Default value: 0.
  	pub min_max_accepted_htlcs: u16,
- 	/// Outputs below a certain value will not be added to on-chain transactions. The dust value is
- 	/// required to always be higher than this value so this only applies to HTLC outputs (and
- 	/// potentially to-self outputs before any payments have been made).
- 	/// Thus, HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain.
- 	/// This setting allows you to set a minimum dust limit for their commitment transactions,
- 	/// reflecting the reality that tiny outputs are not considered standard transactions and will
- 	/// not propagate through the Bitcoin network.
- 	///
- 	/// Default value: 546, the current dust limit on the Bitcoin network.
- 	pub min_dust_limit_satoshis: u64,
- 	/// Maximum allowed threshold above which outputs will not be generated in their commitment
- 	/// transactions.
- 	/// HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain.
- 	///
- 	/// Default value: u64::max_value.
- 	pub max_dust_limit_satoshis: u64,
  	/// Before a channel is usable the funding transaction will need to be confirmed by at least a
  	/// certain number of blocks, specified by the node which is not the funder (as the funder can
  	/// assume they aren't going to double-spend themselves).
@@@ -145,8 -129,6 +129,6 @@@ impl Default for ChannelHandshakeLimit
  			min_max_htlc_value_in_flight_msat: 0,
  			max_channel_reserve_satoshis: <u64>::max_value(),
  			min_max_accepted_htlcs: 0,
- 			min_dust_limit_satoshis: 546,
- 			max_dust_limit_satoshis: <u64>::max_value(),
  			max_minimum_depth: 144,
  			force_announced_channel_preference: true,
  			their_to_self_delay: MAX_LOCAL_BREAKDOWN_TIMEOUT,
@@@ -223,7 -205,7 +205,7 @@@ impl Default for ChannelConfig 
  }
  
  //Add write and readable traits to channelconfig
 -impl_writeable!(ChannelConfig, 8+2+1+1, {
 +impl_writeable!(ChannelConfig, 4+2+1+1, {
  	fee_proportional_millionths,
  	cltv_expiry_delta,
  	announced_channel,