X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Ffunctional_test_utils.rs;h=fa8bdcc58be01ef57547cbf9beaf548be38ca474;hb=6aca7e1c4db17f43b79504fd44b942b4bc08db9d;hp=b695e20a8dd22ba589f2e3cf0a0bd8f4dbad0ddc;hpb=5f96d1334435e74545670a5dff24078edf749d60;p=rust-lightning diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs index b695e20a..fa8bdcc5 100644 --- a/lightning/src/ln/functional_test_utils.rs +++ b/lightning/src/ln/functional_test_utils.rs @@ -10,7 +10,8 @@ //! A bunch of useful utilities for building networks of nodes and exchanging messages between //! nodes for functional tests. -use crate::chain::{BestBlock, ChannelMonitorUpdateStatus, Confirm, Listen, Watch, keysinterface::EntropySource}; +use crate::chain::{BestBlock, ChannelMonitorUpdateStatus, Confirm, Listen, Watch}; +use crate::sign::EntropySource; use crate::chain::channelmonitor::ChannelMonitor; use crate::chain::transaction::OutPoint; use crate::events::{ClosureReason, Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, PathFailure, PaymentPurpose, PaymentFailureReason}; @@ -30,7 +31,6 @@ use crate::util::config::UserConfig; use crate::util::ser::{ReadableArgs, Writeable}; use bitcoin::blockdata::block::{Block, BlockHeader}; -use bitcoin::blockdata::constants::genesis_block; use bitcoin::blockdata::transaction::{Transaction, TxOut}; use bitcoin::network::constants::Network; @@ -85,16 +85,14 @@ pub fn confirm_transactions_at<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, txn: if conf_height > first_connect_height { connect_blocks(node, conf_height - first_connect_height); } - let mut block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: node.best_block_hash(), merkle_root: TxMerkleNode::all_zeros(), time: conf_height, bits: 42, nonce: 42 }, - txdata: Vec::new(), - }; + let mut txdata = Vec::new(); for _ in 0..*node.network_chan_count.borrow() { // Make sure we don't end up with channels at the same short id by offsetting by chan_count - block.txdata.push(Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() }); + txdata.push(Transaction { version: 0, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: Vec::new() }); } for tx in txn { - block.txdata.push((*tx).clone()); + txdata.push((*tx).clone()); } + let block = create_dummy_block(node.best_block_hash(), conf_height, txdata); connect_block(node, &block); scid_utils::scid_from_parts(conf_height as u64, block.txdata.len() as u64 - 1, 0).unwrap() } @@ -191,22 +189,31 @@ impl ConnectStyle { } } +pub fn create_dummy_header(prev_blockhash: BlockHash, time: u32) -> BlockHeader { + BlockHeader { + version: 0x2000_0000, + prev_blockhash, + merkle_root: TxMerkleNode::all_zeros(), + time, + bits: 42, + nonce: 42, + } +} + +pub fn create_dummy_block(prev_blockhash: BlockHash, time: u32, txdata: Vec) -> Block { + Block { header: create_dummy_header(prev_blockhash, time), txdata } +} + pub fn connect_blocks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, depth: u32) -> BlockHash { let skip_intermediaries = node.connect_style.borrow().skips_blocks(); let height = node.best_block_info().1 + 1; - let mut block = Block { - header: BlockHeader { version: 0x2000000, prev_blockhash: node.best_block_hash(), merkle_root: TxMerkleNode::all_zeros(), time: height, bits: 42, nonce: 42 }, - txdata: vec![], - }; + let mut block = create_dummy_block(node.best_block_hash(), height, Vec::new()); assert!(depth >= 1); for i in 1..depth { let prev_blockhash = block.header.block_hash(); do_connect_block(node, block, skip_intermediaries); - block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash, merkle_root: TxMerkleNode::all_zeros(), time: height + i, bits: 42, nonce: 42 }, - txdata: vec![], - }; + block = create_dummy_block(prev_blockhash, height + i, Vec::new()); } let hash = block.header.block_hash(); do_connect_block(node, block, false); @@ -230,6 +237,9 @@ fn do_connect_block<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, block: Block, sk #[cfg(feature = "std")] { eprintln!("Connecting block using Block Connection Style: {:?}", *node.connect_style.borrow()); } + // Update the block internally before handing it over to LDK, to ensure our assertions regarding + // transaction broadcast are correct. + node.blocks.lock().unwrap().push((block.clone(), height)); if !skip_intermediaries { let txdata: Vec<_> = block.txdata.iter().enumerate().collect(); match *node.connect_style.borrow() { @@ -279,7 +289,6 @@ fn do_connect_block<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, block: Block, sk } call_claimable_balances(node); node.node.test_process_background_events(); - node.blocks.lock().unwrap().push((block, height)); } pub fn disconnect_blocks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, count: u32) { @@ -722,6 +731,39 @@ pub fn remove_first_msg_event_to_node(msg_node_id: &PublicKey, msg_events: &mut MessageSendEvent::SendGossipTimestampFilter { node_id, .. } => { node_id == msg_node_id }, + MessageSendEvent::SendAcceptChannelV2 { node_id, .. } => { + node_id == msg_node_id + }, + MessageSendEvent::SendOpenChannelV2 { node_id, .. } => { + node_id == msg_node_id + }, + MessageSendEvent::SendTxAddInput { node_id, .. } => { + node_id == msg_node_id + }, + MessageSendEvent::SendTxAddOutput { node_id, .. } => { + node_id == msg_node_id + }, + MessageSendEvent::SendTxRemoveInput { node_id, .. } => { + node_id == msg_node_id + }, + MessageSendEvent::SendTxRemoveOutput { node_id, .. } => { + node_id == msg_node_id + }, + MessageSendEvent::SendTxComplete { node_id, .. } => { + node_id == msg_node_id + }, + MessageSendEvent::SendTxSignatures { node_id, .. } => { + node_id == msg_node_id + }, + MessageSendEvent::SendTxInitRbf { node_id, .. } => { + node_id == msg_node_id + }, + MessageSendEvent::SendTxAckRbf { node_id, .. } => { + node_id == msg_node_id + }, + MessageSendEvent::SendTxAbort { node_id, .. } => { + node_id == msg_node_id + }, }}); if ev_index.is_some() { msg_events.remove(ev_index.unwrap()) @@ -1696,14 +1738,14 @@ macro_rules! get_payment_preimage_hash { } /// Gets a route from the given sender to the node described in `payment_params`. -pub fn get_route(send_node: &Node, payment_params: &PaymentParameters, recv_value: u64, final_cltv_expiry_delta: u32) -> Result { +pub fn get_route(send_node: &Node, payment_params: &PaymentParameters, recv_value: u64) -> Result { let scorer = TestScorer::new(); let keys_manager = TestKeysInterface::new(&[0u8; 32], bitcoin::network::constants::Network::Testnet); let random_seed_bytes = keys_manager.get_secure_random_bytes(); router::get_route( &send_node.node.get_our_node_id(), payment_params, &send_node.network_graph.read_only(), Some(&send_node.node.list_usable_channels().iter().collect::>()), - recv_value, final_cltv_expiry_delta, send_node.logger, &scorer, &random_seed_bytes + recv_value, send_node.logger, &scorer, &(), &random_seed_bytes ) } @@ -1712,8 +1754,8 @@ pub fn get_route(send_node: &Node, payment_params: &PaymentParameters, recv_valu /// Don't use this, use the identically-named function instead. #[macro_export] macro_rules! get_route { - ($send_node: expr, $payment_params: expr, $recv_value: expr, $cltv: expr) => { - $crate::ln::functional_test_utils::get_route(&$send_node, &$payment_params, $recv_value, $cltv) + ($send_node: expr, $payment_params: expr, $recv_value: expr) => { + $crate::ln::functional_test_utils::get_route(&$send_node, &$payment_params, $recv_value) } } @@ -1722,13 +1764,13 @@ macro_rules! get_route { macro_rules! get_route_and_payment_hash { ($send_node: expr, $recv_node: expr, $recv_value: expr) => {{ let payment_params = $crate::routing::router::PaymentParameters::from_node_id($recv_node.node.get_our_node_id(), TEST_FINAL_CLTV) - .with_features($recv_node.node.invoice_features()); - $crate::get_route_and_payment_hash!($send_node, $recv_node, payment_params, $recv_value, TEST_FINAL_CLTV) + .with_bolt11_features($recv_node.node.invoice_features()).unwrap(); + $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, $cltv: expr) => {{ + ($send_node: expr, $recv_node: expr, $payment_params: expr, $recv_value: expr) => {{ 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, &$payment_params, $recv_value, $cltv); + let route = $crate::ln::functional_test_utils::get_route(&$send_node, &$payment_params, $recv_value); (route.unwrap(), payment_hash, payment_preimage, payment_secret) }} } @@ -2271,11 +2313,11 @@ pub const TEST_FINAL_CLTV: u32 = 70; pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash, PaymentSecret) { let payment_params = PaymentParameters::from_node_id(expected_route.last().unwrap().node.get_our_node_id(), TEST_FINAL_CLTV) - .with_features(expected_route.last().unwrap().node.invoice_features()); - let route = get_route(origin_node, &payment_params, recv_value, TEST_FINAL_CLTV).unwrap(); + .with_bolt11_features(expected_route.last().unwrap().node.invoice_features()).unwrap(); + let route = get_route(origin_node, &payment_params, recv_value).unwrap(); assert_eq!(route.paths.len(), 1); - assert_eq!(route.paths[0].len(), expected_route.len()); - for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) { + assert_eq!(route.paths[0].hops.len(), expected_route.len()); + for (node, hop) in expected_route.iter().zip(route.paths[0].hops.iter()) { assert_eq!(hop.pubkey, node.node.get_our_node_id()); } @@ -2285,7 +2327,7 @@ pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: pub fn route_over_limit<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) { let payment_params = PaymentParameters::from_node_id(expected_route.last().unwrap().node.get_our_node_id(), TEST_FINAL_CLTV) - .with_features(expected_route.last().unwrap().node.invoice_features()); + .with_bolt11_features(expected_route.last().unwrap().node.invoice_features()).unwrap(); let network_graph = origin_node.network_graph.read_only(); let scorer = test_utils::TestScorer::new(); let seed = [0u8; 32]; @@ -2293,10 +2335,10 @@ pub fn route_over_limit<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_rou let random_seed_bytes = keys_manager.get_secure_random_bytes(); let route = router::get_route( &origin_node.node.get_our_node_id(), &payment_params, &network_graph, - None, recv_value, TEST_FINAL_CLTV, origin_node.logger, &scorer, &random_seed_bytes).unwrap(); + None, recv_value, origin_node.logger, &scorer, &(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); - assert_eq!(route.paths[0].len(), expected_route.len()); - for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) { + assert_eq!(route.paths[0].hops.len(), expected_route.len()); + for (node, hop) in expected_route.iter().zip(route.paths[0].hops.iter()) { assert_eq!(hop.pubkey, node.node.get_our_node_id()); } @@ -2402,7 +2444,7 @@ pub fn pass_failed_payment_back<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expe assert_eq!(payment_hash, our_payment_hash); assert!(payment_failed_permanently); for (idx, hop) in expected_route.iter().enumerate() { - assert_eq!(hop.node.get_our_node_id(), path[idx].pubkey); + assert_eq!(hop.node.get_our_node_id(), path.hops[idx].pubkey); } payment_id.unwrap() }, @@ -2435,10 +2477,7 @@ pub fn fail_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_path: & pub fn create_chanmon_cfgs(node_count: usize) -> Vec { let mut chan_mon_cfgs = Vec::new(); for i in 0..node_count { - let tx_broadcaster = test_utils::TestBroadcaster { - txn_broadcasted: Mutex::new(Vec::new()), - blocks: Arc::new(Mutex::new(vec![(genesis_block(Network::Testnet), 0)])), - }; + let tx_broadcaster = test_utils::TestBroadcaster::new(Network::Testnet); let fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) }; let chain_source = test_utils::TestChainSource::new(Network::Testnet); let logger = test_utils::TestLogger::with_id(format!("node {}", i));