Apply a default max fee rather than none when paying for BOLT12

[rust-lightning] / lightning / src / util / test_utils.rs

diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs
index 8a988b629079647e8cc85c166e3b874986ec1b3e..d42a84d361d45a56ebb83933e66ff4fa34e10e4d 100644 (file)
--- a/lightning/src/util/test_utils.rs
+++ b/lightning/src/util/test_utils.rs
@@ -94,8 +94,13 @@ pub struct TestFeeEstimator {
        pub sat_per_kw: Mutex<u32>,
 }
 impl chaininterface::FeeEstimator for TestFeeEstimator {
-       fn get_est_sat_per_1000_weight(&self, _confirmation_target: ConfirmationTarget) -> u32 {
-               *self.sat_per_kw.lock().unwrap()
+       fn get_est_sat_per_1000_weight(&self, confirmation_target: ConfirmationTarget) -> u32 {
+               match confirmation_target {
+                       ConfirmationTarget::MaxAllowedNonAnchorChannelRemoteFee => {
+                               core::cmp::max(25 * 250, *self.sat_per_kw.lock().unwrap() * 10)
+                       }
+                       _ => *self.sat_per_kw.lock().unwrap(),
+               }
        }
 }
 
@@ -581,17 +586,17 @@ pub struct TestChannelMessageHandler {
        expected_recv_msgs: Mutex<Option<Vec<wire::Message<()>>>>,
        connected_peers: Mutex<HashSet<PublicKey>>,
        pub message_fetch_counter: AtomicUsize,
-       genesis_hash: ChainHash,
+       chain_hash: ChainHash,
 }
 
 impl TestChannelMessageHandler {
-       pub fn new(genesis_hash: ChainHash) -> Self {
+       pub fn new(chain_hash: ChainHash) -> Self {
                TestChannelMessageHandler {
                        pending_events: Mutex::new(Vec::new()),
                        expected_recv_msgs: Mutex::new(None),
                        connected_peers: Mutex::new(HashSet::new()),
                        message_fetch_counter: AtomicUsize::new(0),
-                       genesis_hash,
+                       chain_hash,
                }
        }
 
@@ -695,8 +700,8 @@ impl msgs::ChannelMessageHandler for TestChannelMessageHandler {
                channelmanager::provided_init_features(&UserConfig::default())
        }
 
-       fn get_genesis_hashes(&self) -> Option<Vec<ChainHash>> {
-               Some(vec![self.genesis_hash])
+       fn get_chain_hashes(&self) -> Option<Vec<ChainHash>> {
+               Some(vec![self.chain_hash])
        }
 
        fn handle_open_channel_v2(&self, _their_node_id: &PublicKey, msg: &msgs::OpenChannelV2) {
@@ -764,7 +769,7 @@ fn get_dummy_channel_announcement(short_chan_id: u64) -> msgs::ChannelAnnounceme
        let node_2_btckey = SecretKey::from_slice(&[39; 32]).unwrap();
        let unsigned_ann = msgs::UnsignedChannelAnnouncement {
                features: ChannelFeatures::empty(),
-               chain_hash: genesis_block(network).header.block_hash(),
+               chain_hash: ChainHash::using_genesis_block(network),
                short_channel_id: short_chan_id,
                node_id_1: NodeId::from_pubkey(&PublicKey::from_secret_key(&secp_ctx, &node_1_privkey)),
                node_id_2: NodeId::from_pubkey(&PublicKey::from_secret_key(&secp_ctx, &node_2_privkey)),
@@ -790,7 +795,7 @@ fn get_dummy_channel_update(short_chan_id: u64) -> msgs::ChannelUpdate {
        msgs::ChannelUpdate {
                signature: Signature::from(unsafe { FFISignature::new() }),
                contents: msgs::UnsignedChannelUpdate {
-                       chain_hash: genesis_block(network).header.block_hash(),
+                       chain_hash: ChainHash::using_genesis_block(network),
                        short_channel_id: short_chan_id,
                        timestamp: 0,
                        flags: 0,
@@ -866,7 +871,7 @@ impl msgs::RoutingMessageHandler for TestRoutingMessageHandler {
                pending_events.push(events::MessageSendEvent::SendGossipTimestampFilter {
                        node_id: their_node_id.clone(),
                        msg: msgs::GossipTimestampFilter {
-                               chain_hash: genesis_block(Network::Testnet).header.block_hash(),
+                               chain_hash: ChainHash::using_genesis_block(Network::Testnet),
                                first_timestamp: gossip_start_time as u32,
                                timestamp_range: u32::max_value(),
                        },
@@ -969,8 +974,10 @@ impl Logger for TestLogger {
        fn log(&self, record: &Record) {
                *self.lines.lock().unwrap().entry((record.module_path.to_string(), format!("{}", record.args))).or_insert(0) += 1;
                if record.level >= self.level {
-                       #[cfg(all(not(ldk_bench), feature = "std"))]
-                       println!("{:<5} {} [{} : {}, {}] {}", record.level.to_string(), self.id, record.module_path, record.file, record.line, record.args);
+                       #[cfg(all(not(ldk_bench), feature = "std"))] {
+                               let pfx = format!("{} {} [{}:{}]", self.id, record.level.to_string(), record.module_path, record.line);
+                               println!("{:<55}{}", pfx, record.args);
+                       }
                }
        }
 }
@@ -1195,7 +1202,7 @@ impl core::fmt::Debug for OnGetShutdownScriptpubkey {
 }
 
 pub struct TestChainSource {
-       pub genesis_hash: BlockHash,
+       pub chain_hash: ChainHash,
        pub utxo_ret: Mutex<UtxoResult>,
        pub get_utxo_call_count: AtomicUsize,
        pub watched_txn: Mutex<HashSet<(Txid, Script)>>,
@@ -1206,7 +1213,7 @@ impl TestChainSource {
        pub fn new(network: Network) -> Self {
                let script_pubkey = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
                Self {
-                       genesis_hash: genesis_block(network).block_hash(),
+                       chain_hash: ChainHash::using_genesis_block(network),
                        utxo_ret: Mutex::new(UtxoResult::Sync(Ok(TxOut { value: u64::max_value(), script_pubkey }))),
                        get_utxo_call_count: AtomicUsize::new(0),
                        watched_txn: Mutex::new(HashSet::new()),
@@ -1216,9 +1223,9 @@ impl TestChainSource {
 }
 
 impl UtxoLookup for TestChainSource {
-       fn get_utxo(&self, genesis_hash: &BlockHash, _short_channel_id: u64) -> UtxoResult {
+       fn get_utxo(&self, chain_hash: &ChainHash, _short_channel_id: u64) -> UtxoResult {
                self.get_utxo_call_count.fetch_add(1, Ordering::Relaxed);
-               if self.genesis_hash != *genesis_hash {
+               if self.chain_hash != *chain_hash {
                        return UtxoResult::Sync(Err(UtxoLookupError::UnknownChain));
                }