Skip to content

Commit 98ba1fb

Browse files
carlaKCcarlaKC
committed
ln/refactor: remove channel test fee estimator and clean up imports
1 parent 901f72d commit 98ba1fb

File tree

1 file changed

+59
-57
lines changed

1 file changed

+59
-57
lines changed

‎lightning/src/ln/channel.rs‎

Lines changed: 59 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -11784,15 +11784,14 @@ mod tests {
1178411784
use crate::ln::script::ShutdownScript;
1178511785
use crate::ln::chan_utils::{self, htlc_success_tx_weight, htlc_timeout_tx_weight};
1178611786
use crate::chain::BestBlock;
11787-
use crate::chain::chaininterface::{FeeEstimator, LowerBoundedFeeEstimator, ConfirmationTarget};
11787+
use crate::chain::chaininterface::LowerBoundedFeeEstimator;
1178811788
use crate::sign::{ChannelSigner, InMemorySigner, EntropySource, SignerProvider};
1178911789
use crate::chain::transaction::OutPoint;
1179011790
use crate::routing::router::{Path, RouteHop};
1179111791
use crate::util::config::UserConfig;
1179211792
use crate::util::errors::APIError;
1179311793
use crate::util::ser::{ReadableArgs, Writeable};
11794-
use crate::util::test_utils;
11795-
use crate::util::test_utils::{OnGetShutdownScriptpubkey, TestKeysInterface};
11794+
use crate::util::test_utils::{self, OnGetShutdownScriptpubkey, TestKeysInterface, TestFeeEstimator, TestLogger};
1179611795
use bitcoin::secp256k1::{Secp256k1, ecdsa::Signature};
1179711796
use bitcoin::secp256k1::ffi::Signature as FFISignature;
1179811797
use bitcoin::secp256k1::{SecretKey,PublicKey};
@@ -11816,15 +11815,6 @@ mod tests {
1181611815
assert!(ChannelState::ChannelReady(ChannelReadyFlags::new()) < ChannelState::ShutdownComplete);
1181711816
}
1181811817

11819-
struct TestFeeEstimator {
11820-
fee_est: u32
11821-
}
11822-
impl FeeEstimator for TestFeeEstimator {
11823-
fn get_est_sat_per_1000_weight(&self, _: ConfirmationTarget) -> u32 {
11824-
self.fee_est
11825-
}
11826-
}
11827-
1182811818
#[test]
1182911819
fn test_max_funding_satoshis_no_wumbo() {
1183011820
assert_eq!(TOTAL_BITCOIN_SUPPLY_SATOSHIS, 21_000_000 * 100_000_000);
@@ -11883,16 +11873,16 @@ mod tests {
1188311873

1188411874
let seed = [42; 32];
1188511875
let network = Network::Testnet;
11886-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
11876+
let keys_provider = TestKeysInterface::new(&seed, network);
1188711877
keys_provider.expect(OnGetShutdownScriptpubkey {
1188811878
returns: non_v0_segwit_shutdown_script.clone(),
1188911879
});
11890-
let logger = test_utils::TestLogger::new();
11880+
let logger = TestLogger::new();
1189111881

1189211882
let secp_ctx = Secp256k1::new();
1189311883
let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1189411884
let config = UserConfig::default();
11895-
match OutboundV1Channel::<&TestKeysInterface>::new(&LowerBoundedFeeEstimator::new(&TestFeeEstimator { fee_est: 253 }), &&keys_provider, &&keys_provider, node_id, &features, 10000000, 100000, 42, &config, 0, 42, None, &logger) {
11885+
match OutboundV1Channel::<&TestKeysInterface>::new(&LowerBoundedFeeEstimator::new(&TestFeeEstimator::new(253)), &&keys_provider, &&keys_provider, node_id, &features, 10000000, 100000, 42, &config, 0, 42, None, &logger) {
1189611886
Err(APIError::IncompatibleShutdownScript { script }) => {
1189711887
assert_eq!(script.into_inner(), non_v0_segwit_shutdown_script.into_inner());
1189811888
},
@@ -11906,21 +11896,21 @@ mod tests {
1190611896
#[test]
1190711897
fn test_open_channel_msg_fee() {
1190811898
let original_fee = 253;
11909-
let mut fee_est = TestFeeEstimator{fee_est: original_fee };
11899+
let fee_est = TestFeeEstimator::new(original_fee);
1191011900
let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_est);
1191111901
let secp_ctx = Secp256k1::new();
1191211902
let seed = [42; 32];
1191311903
let network = Network::Testnet;
11914-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
11915-
let logger = test_utils::TestLogger::new();
11904+
let keys_provider = TestKeysInterface::new(&seed, network);
11905+
let logger = TestLogger::new();
1191611906

1191711907
let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1191811908
let config = UserConfig::default();
1191911909
let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&bounded_fee_estimator, &&keys_provider, &&keys_provider, node_a_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger).unwrap();
1192011910

1192111911
// Now change the fee so we can check that the fee in the open_channel message is the
1192211912
// same as the old fee.
11923-
fee_est.fee_est = 500;
11913+
*fee_est.sat_per_kw.lock().unwrap() = 500;
1192411914
let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap();
1192511915
assert_eq!(open_channel_msg.common_fields.commitment_feerate_sat_per_1000_weight, original_fee);
1192611916
}
@@ -11929,12 +11919,13 @@ mod tests {
1192911919
fn test_holder_vs_counterparty_dust_limit() {
1193011920
// Test that when calculating the local and remote commitment transaction fees, the correct
1193111921
// dust limits are used.
11932-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
11922+
let test_est = TestFeeEstimator::new(15000);
11923+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
1193311924
let secp_ctx = Secp256k1::new();
1193411925
let seed = [42; 32];
1193511926
let network = Network::Testnet;
11936-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
11937-
let logger = test_utils::TestLogger::new();
11927+
let keys_provider = TestKeysInterface::new(&seed, network);
11928+
let logger = TestLogger::new();
1193811929
let best_block = BestBlock::from_network(network);
1193911930

1194011931
// Go through the flow of opening a channel between two nodes, making sure
@@ -12020,12 +12011,13 @@ mod tests {
1202012011
// calculate the real dust limits for HTLCs (i.e. the dust limit given by the counterparty
1202112012
// *plus* the fees paid for the HTLC) they don't swap `HTLC_SUCCESS_TX_WEIGHT` for
1202212013
// `HTLC_TIMEOUT_TX_WEIGHT`, and vice versa.
12023-
let fee_est = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 253 });
12014+
let test_est = TestFeeEstimator::new(253);
12015+
let fee_est = LowerBoundedFeeEstimator::new(&test_est);
1202412016
let secp_ctx = Secp256k1::new();
1202512017
let seed = [42; 32];
1202612018
let network = Network::Testnet;
12027-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12028-
let logger = test_utils::TestLogger::new();
12019+
let keys_provider = TestKeysInterface::new(&seed, network);
12020+
let logger = TestLogger::new();
1202912021

1203012022
let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1203112023
let config = UserConfig::default();
@@ -12064,14 +12056,15 @@ mod tests {
1206412056

1206512057
#[test]
1206612058
fn channel_reestablish_no_updates() {
12067-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
12068-
let logger = test_utils::TestLogger::new();
12059+
let test_est = TestFeeEstimator::new(15000);
12060+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
12061+
let logger = TestLogger::new();
1206912062
let secp_ctx = Secp256k1::new();
1207012063
let seed = [42; 32];
1207112064
let network = Network::Testnet;
1207212065
let best_block = BestBlock::from_network(network);
1207312066
let chain_hash = ChainHash::using_genesis_block(network);
12074-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12067+
let keys_provider = TestKeysInterface::new(&seed, network);
1207512068

1207612069
// Go through the flow of opening a channel between two nodes.
1207712070

@@ -12121,12 +12114,13 @@ mod tests {
1212112114

1212212115
#[test]
1212312116
fn test_configured_holder_max_htlc_value_in_flight() {
12124-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
12125-
let logger = test_utils::TestLogger::new();
12117+
let test_est = TestFeeEstimator::new(15000);
12118+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
12119+
let logger = TestLogger::new();
1212612120
let secp_ctx = Secp256k1::new();
1212712121
let seed = [42; 32];
1212812122
let network = Network::Testnet;
12129-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12123+
let keys_provider = TestKeysInterface::new(&seed, network);
1213012124
let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1213112125
let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
1213212126

@@ -12215,12 +12209,13 @@ mod tests {
1221512209
}
1221612210

1221712211
fn test_self_and_counterparty_channel_reserve(channel_value_satoshis: u64, outbound_selected_channel_reserve_perc: f64, inbound_selected_channel_reserve_perc: f64) {
12218-
let fee_est = LowerBoundedFeeEstimator::new(&TestFeeEstimator { fee_est: 15_000 });
12219-
let logger = test_utils::TestLogger::new();
12212+
let test_est = TestFeeEstimator::new(15000);
12213+
let fee_est = LowerBoundedFeeEstimator::new(&test_est);
12214+
let logger = TestLogger::new();
1222012215
let secp_ctx = Secp256k1::new();
1222112216
let seed = [42; 32];
1222212217
let network = Network::Testnet;
12223-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12218+
let keys_provider = TestKeysInterface::new(&seed, network);
1222412219
let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1222512220
let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
1222612221

@@ -12252,14 +12247,15 @@ mod tests {
1225212247

1225312248
#[test]
1225412249
fn channel_update() {
12255-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
12256-
let logger = test_utils::TestLogger::new();
12250+
let test_est = TestFeeEstimator::new(15000);
12251+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
12252+
let logger = TestLogger::new();
1225712253
let secp_ctx = Secp256k1::new();
1225812254
let seed = [42; 32];
1225912255
let network = Network::Testnet;
1226012256
let best_block = BestBlock::from_network(network);
1226112257
let chain_hash = ChainHash::using_genesis_block(network);
12262-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12258+
let keys_provider = TestKeysInterface::new(&seed, network);
1226312259

1226412260
// Create Node A's channel pointing to Node B's pubkey
1226512261
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
@@ -12329,13 +12325,14 @@ mod tests {
1232912325
fn blinding_point_skimmed_fee_malformed_ser() {
1233012326
// Ensure that channel blinding points, skimmed fees, and malformed HTLCs are (de)serialized
1233112327
// properly.
12332-
let logger = test_utils::TestLogger::new();
12333-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
12328+
let logger = TestLogger::new();
12329+
let test_est = TestFeeEstimator::new(15000);
12330+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
1233412331
let secp_ctx = Secp256k1::new();
1233512332
let seed = [42; 32];
1233612333
let network = Network::Testnet;
1233712334
let best_block = BestBlock::from_network(network);
12338-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12335+
let keys_provider = TestKeysInterface::new(&seed, network);
1233912336

1234012337
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1234112338
let config = UserConfig::default();
@@ -12474,8 +12471,8 @@ mod tests {
1247412471
use core::str::FromStr;
1247512472

1247612473
// Test vectors from BOLT 3 Appendices C and F (anchors):
12477-
let feeest = TestFeeEstimator{fee_est: 15000};
12478-
let logger : Arc<dyn Logger> = Arc::new(test_utils::TestLogger::new());
12474+
let feeest = TestFeeEstimator::new(15000);
12475+
let logger : Arc<dyn Logger> = Arc::new(TestLogger::new());
1247912476
let secp_ctx = Secp256k1::new();
1248012477

1248112478
let signer = InMemorySigner::new(
@@ -13235,12 +13232,13 @@ mod tests {
1323513232

1323613233
#[test]
1323713234
fn test_zero_conf_channel_type_support() {
13238-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
13235+
let test_est = TestFeeEstimator::new(15000);
13236+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
1323913237
let secp_ctx = Secp256k1::new();
1324013238
let seed = [42; 32];
1324113239
let network = Network::Testnet;
13242-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
13243-
let logger = test_utils::TestLogger::new();
13240+
let keys_provider = TestKeysInterface::new(&seed, network);
13241+
let logger = TestLogger::new();
1324413242

1324513243
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1324613244
let config = UserConfig::default();
@@ -13264,10 +13262,11 @@ mod tests {
1326413262
// Tests that if both sides support and negotiate `anchors_zero_fee_htlc_tx`, it is the
1326513263
// resulting `channel_type`.
1326613264
let secp_ctx = Secp256k1::new();
13267-
let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
13265+
let test_est = TestFeeEstimator::new(15000);
13266+
let fee_estimator = LowerBoundedFeeEstimator::new(&test_est);
1326813267
let network = Network::Testnet;
13269-
let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
13270-
let logger = test_utils::TestLogger::new();
13268+
let keys_provider = TestKeysInterface::new(&[42; 32], network);
13269+
let logger = TestLogger::new();
1327113270

1327213271
let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
1327313272
let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
@@ -13310,10 +13309,11 @@ mod tests {
1331013309
// Tests that if `option_anchors` is being negotiated implicitly through the intersection of
1331113310
// each side's `InitFeatures`, it is rejected.
1331213311
let secp_ctx = Secp256k1::new();
13313-
let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
13312+
let test_est = TestFeeEstimator::new(15000);
13313+
let fee_estimator = LowerBoundedFeeEstimator::new(&test_est);
1331413314
let network = Network::Testnet;
13315-
let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
13316-
let logger = test_utils::TestLogger::new();
13315+
let keys_provider = TestKeysInterface::new(&[42; 32], network);
13316+
let logger = TestLogger::new();
1331713317

1331813318
let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
1331913319
let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
@@ -13351,10 +13351,11 @@ mod tests {
1335113351
// Tests that if `option_anchors` is being negotiated through the `channel_type` feature,
1335213352
// it is rejected.
1335313353
let secp_ctx = Secp256k1::new();
13354-
let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
13354+
let test_est = TestFeeEstimator::new(15000);
13355+
let fee_estimator = LowerBoundedFeeEstimator::new(&test_est);
1335513356
let network = Network::Testnet;
13356-
let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
13357-
let logger = test_utils::TestLogger::new();
13357+
let keys_provider = TestKeysInterface::new(&[42; 32], network);
13358+
let logger = TestLogger::new();
1335813359

1335913360
let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
1336013361
let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
@@ -13417,14 +13418,15 @@ mod tests {
1341713418

1341813419
#[test]
1341913420
fn test_waiting_for_batch() {
13420-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
13421-
let logger = test_utils::TestLogger::new();
13421+
let test_est = TestFeeEstimator::new(15000);
13422+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
13423+
let logger = TestLogger::new();
1342213424
let secp_ctx = Secp256k1::new();
1342313425
let seed = [42; 32];
1342413426
let network = Network::Testnet;
1342513427
let best_block = BestBlock::from_network(network);
1342613428
let chain_hash = ChainHash::using_genesis_block(network);
13427-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
13429+
let keys_provider = TestKeysInterface::new(&seed, network);
1342813430

1342913431
let mut config = UserConfig::default();
1343013432
// Set trust_own_funding_0conf while ensuring we don't send channel_ready for a

0 commit comments

Comments
 (0)