X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Ffunctional_test_utils.rs;h=207c0692031a7c89b9f2f6c75da9fc71997abcc3;hb=336d815dd62647382961acd9b11904e96d755bb0;hp=f6684485dba0d69964686b145b9fd3b383c854cc;hpb=daf79f515fd4344c4ca278782500cb876b61749c;p=rust-lightning

diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
index f6684485..207c0692 100644
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -422,6 +422,10 @@ pub struct Node<'chan_man, 'node_cfg: 'chan_man, 'chan_mon_cfg: 'node_cfg> {
 		&'chan_mon_cfg test_utils::TestLogger,
 	>,
 }
+#[cfg(feature = "std")]
+impl<'a, 'b, 'c> std::panic::UnwindSafe for Node<'a, 'b, 'c> {}
+#[cfg(feature = "std")]
+impl<'a, 'b, 'c> std::panic::RefUnwindSafe for Node<'a, 'b, 'c> {}
 impl<'a, 'b, 'c> Node<'a, 'b, 'c> {
 	pub fn best_block_hash(&self) -> BlockHash {
 		self.blocks.lock().unwrap().last().unwrap().0.block_hash()
@@ -578,7 +582,7 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
 			let chain_source = test_utils::TestChainSource::new(Network::Testnet);
 			let chain_monitor = test_utils::TestChainMonitor::new(Some(&chain_source), &broadcaster, &self.logger, &feeest, &persister, &self.keys_manager);
 			for deserialized_monitor in deserialized_monitors.drain(..) {
-				if chain_monitor.watch_channel(deserialized_monitor.get_funding_txo().0, deserialized_monitor) != ChannelMonitorUpdateStatus::Completed {
+				if chain_monitor.watch_channel(deserialized_monitor.get_funding_txo().0, deserialized_monitor) != Ok(ChannelMonitorUpdateStatus::Completed) {
 					panic!();
 				}
 			}
@@ -977,7 +981,7 @@ pub fn _reload_node<'a, 'b, 'c>(node: &'a Node<'a, 'b, 'c>, default_config: User
 
 	for monitor in monitors_read.drain(..) {
 		assert_eq!(node.chain_monitor.watch_channel(monitor.get_funding_txo().0, monitor),
-			ChannelMonitorUpdateStatus::Completed);
+			Ok(ChannelMonitorUpdateStatus::Completed));
 		check_added_monitors!(node, 1);
 	}
 
@@ -1469,12 +1473,12 @@ pub fn check_closed_event(node: &Node, events_count: usize, expected_reason: Clo
 	let events = node.node.get_and_clear_pending_events();
 	assert_eq!(events.len(), events_count, "{:?}", events);
 	let mut issues_discard_funding = false;
-	for (idx, event) in events.into_iter().enumerate() {
+	for event in events {
 		match event {
-			Event::ChannelClosed { ref reason, counterparty_node_id, 
+			Event::ChannelClosed { ref reason, counterparty_node_id,
 				channel_capacity_sats, .. } => {
 				assert_eq!(*reason, expected_reason);
-				assert_eq!(counterparty_node_id.unwrap(), expected_counterparty_node_ids[idx]);
+				assert!(expected_counterparty_node_ids.iter().any(|id| id == &counterparty_node_id.unwrap()));
 				assert_eq!(channel_capacity_sats.unwrap(), expected_channel_capacity);
 			},
 			Event::DiscardFunding { .. } => {
@@ -1495,7 +1499,7 @@ macro_rules! check_closed_event {
 		check_closed_event!($node, $events, $reason, false, $counterparty_node_ids, $channel_capacity);
 	};
 	($node: expr, $events: expr, $reason: expr, $is_check_discard_funding: expr, $counterparty_node_ids: expr, $channel_capacity: expr) => {
-		$crate::ln::functional_test_utils::check_closed_event(&$node, $events, $reason, 
+		$crate::ln::functional_test_utils::check_closed_event(&$node, $events, $reason,
 			$is_check_discard_funding, &$counterparty_node_ids, $channel_capacity);
 	}
 }
@@ -1854,7 +1858,7 @@ pub fn get_route(send_node: &Node, route_params: &RouteParameters) -> Result<Rou
 	router::get_route(
 		&send_node.node.get_our_node_id(), route_params, &send_node.network_graph.read_only(),
 		Some(&send_node.node.list_usable_channels().iter().collect::<Vec<_>>()),
-		send_node.logger, &scorer, &(), &random_seed_bytes
+		send_node.logger, &scorer, &Default::default(), &random_seed_bytes
 	)
 }
 
@@ -1878,7 +1882,11 @@ macro_rules! get_route_and_payment_hash {
 		$crate::get_route_and_payment_hash!($send_node, $recv_node, payment_params, $recv_value)
 	}};
 	($send_node: expr, $recv_node: expr, $payment_params: expr, $recv_value: expr) => {{
-		let route_params = $crate::routing::router::RouteParameters::from_payment_params_and_value($payment_params, $recv_value);
+		$crate::get_route_and_payment_hash!($send_node, $recv_node, $payment_params, $recv_value, None)
+	}};
+	($send_node: expr, $recv_node: expr, $payment_params: expr, $recv_value: expr, $max_total_routing_fee_msat: expr) => {{
+		let mut route_params = $crate::routing::router::RouteParameters::from_payment_params_and_value($payment_params, $recv_value);
+		route_params.max_total_routing_fee_msat = $max_total_routing_fee_msat;
 		let (payment_preimage, payment_hash, payment_secret) =
 			$crate::ln::functional_test_utils::get_payment_preimage_hash(&$recv_node, Some($recv_value), None);
 		let route = $crate::ln::functional_test_utils::get_route(&$send_node, &route_params);
@@ -2506,7 +2514,7 @@ pub fn route_over_limit<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_rou
 	let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
 	let random_seed_bytes = keys_manager.get_secure_random_bytes();
 	let route = router::get_route(&origin_node.node.get_our_node_id(), &route_params, &network_graph,
-		None, origin_node.logger, &scorer, &(), &random_seed_bytes).unwrap();
+		None, origin_node.logger, &scorer, &Default::default(), &random_seed_bytes).unwrap();
 	assert_eq!(route.paths.len(), 1);
 	assert_eq!(route.paths[0].hops.len(), expected_route.len());
 	for (node, hop) in expected_route.iter().zip(route.paths[0].hops.iter()) {
@@ -3258,3 +3266,76 @@ pub fn reconnect_nodes<'a, 'b, 'c, 'd>(args: ReconnectArgs<'a, 'b, 'c, 'd>) {
 		}
 	}
 }
+
+/// Initiates channel opening and creates a single batch funding transaction.
+/// This will go through the open_channel / accept_channel flow, and return the batch funding
+/// transaction with corresponding funding_created messages.
+pub fn create_batch_channel_funding<'a, 'b, 'c>(
+	funding_node: &Node<'a, 'b, 'c>,
+	params: &[(&Node<'a, 'b, 'c>, u64, u64, u128, Option<UserConfig>)],
+) -> (Transaction, Vec<msgs::FundingCreated>) {
+	let mut tx_outs = Vec::new();
+	let mut temp_chan_ids = Vec::new();
+	let mut funding_created_msgs = Vec::new();
+
+	for (other_node, channel_value_satoshis, push_msat, user_channel_id, override_config) in params {
+		// Initialize channel opening.
+		let temp_chan_id = funding_node.node.create_channel(
+			other_node.node.get_our_node_id(), *channel_value_satoshis, *push_msat, *user_channel_id,
+			*override_config,
+		).unwrap();
+		let open_channel_msg = get_event_msg!(funding_node, MessageSendEvent::SendOpenChannel, other_node.node.get_our_node_id());
+		other_node.node.handle_open_channel(&funding_node.node.get_our_node_id(), &open_channel_msg);
+		let accept_channel_msg = get_event_msg!(other_node, MessageSendEvent::SendAcceptChannel, funding_node.node.get_our_node_id());
+		funding_node.node.handle_accept_channel(&other_node.node.get_our_node_id(), &accept_channel_msg);
+
+		// Create the corresponding funding output.
+		let events = funding_node.node.get_and_clear_pending_events();
+		assert_eq!(events.len(), 1);
+		match events[0] {
+			Event::FundingGenerationReady {
+				ref temporary_channel_id,
+				ref counterparty_node_id,
+				channel_value_satoshis: ref event_channel_value_satoshis,
+				ref output_script,
+				user_channel_id: ref event_user_channel_id
+			} => {
+				assert_eq!(temporary_channel_id, &temp_chan_id);
+				assert_eq!(counterparty_node_id, &other_node.node.get_our_node_id());
+				assert_eq!(channel_value_satoshis, event_channel_value_satoshis);
+				assert_eq!(user_channel_id, event_user_channel_id);
+				tx_outs.push(TxOut {
+					value: *channel_value_satoshis, script_pubkey: output_script.clone(),
+				});
+			},
+			_ => panic!("Unexpected event"),
+		};
+		temp_chan_ids.push((temp_chan_id, other_node.node.get_our_node_id()));
+	}
+
+	// Compose the batch funding transaction and give it to the ChannelManager.
+	let tx = Transaction {
+		version: 2,
+		lock_time: PackedLockTime::ZERO,
+		input: Vec::new(),
+		output: tx_outs,
+	};
+	assert!(funding_node.node.batch_funding_transaction_generated(
+		temp_chan_ids.iter().map(|(a, b)| (a, b)).collect::<Vec<_>>().as_slice(),
+		tx.clone(),
+	).is_ok());
+	check_added_monitors!(funding_node, 0);
+	let events = funding_node.node.get_and_clear_pending_msg_events();
+	assert_eq!(events.len(), params.len());
+	for (other_node, ..) in params {
+		let funding_created = events
+			.iter()
+			.find_map(|event| match event {
+				MessageSendEvent::SendFundingCreated { node_id, msg } if node_id == &other_node.node.get_our_node_id() => Some(msg.clone()),
+				_ => None,
+			})
+			.unwrap();
+		funding_created_msgs.push(funding_created);
+	}
+	return (tx, funding_created_msgs);
+}