Skip to content

Commit 7c04596

Browse files
carlaKCcarlaKC
committed
ln/refactor: remove channel test fee estimator and clean up imports
1 parent 0848e7a commit 7c04596

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
@@ -11853,15 +11853,14 @@ mod tests {
1185311853
use crate::ln::script::ShutdownScript;
1185411854
use crate::ln::chan_utils::{self, htlc_success_tx_weight, htlc_timeout_tx_weight};
1185511855
use crate::chain::BestBlock;
11856-
use crate::chain::chaininterface::{FeeEstimator, LowerBoundedFeeEstimator, ConfirmationTarget};
11856+
use crate::chain::chaininterface::LowerBoundedFeeEstimator;
1185711857
use crate::sign::{ChannelSigner, InMemorySigner, EntropySource, SignerProvider};
1185811858
use crate::chain::transaction::OutPoint;
1185911859
use crate::routing::router::{Path, RouteHop};
1186011860
use crate::util::config::UserConfig;
1186111861
use crate::util::errors::APIError;
1186211862
use crate::util::ser::{ReadableArgs, Writeable};
11863-
use crate::util::test_utils;
11864-
use crate::util::test_utils::{OnGetShutdownScriptpubkey, TestKeysInterface};
11863+
use crate::util::test_utils::{self, OnGetShutdownScriptpubkey, TestKeysInterface, TestFeeEstimator, TestLogger};
1186511864
use bitcoin::secp256k1::{Secp256k1, ecdsa::Signature};
1186611865
use bitcoin::secp256k1::ffi::Signature as FFISignature;
1186711866
use bitcoin::secp256k1::{SecretKey,PublicKey};
@@ -11885,15 +11884,6 @@ mod tests {
1188511884
assert!(ChannelState::ChannelReady(ChannelReadyFlags::new()) < ChannelState::ShutdownComplete);
1188611885
}
1188711886

11888-
struct TestFeeEstimator {
11889-
fee_est: u32
11890-
}
11891-
impl FeeEstimator for TestFeeEstimator {
11892-
fn get_est_sat_per_1000_weight(&self, _: ConfirmationTarget) -> u32 {
11893-
self.fee_est
11894-
}
11895-
}
11896-
1189711887
#[test]
1189811888
fn test_max_funding_satoshis_no_wumbo() {
1189911889
assert_eq!(TOTAL_BITCOIN_SUPPLY_SATOSHIS, 21_000_000 * 100_000_000);
@@ -11952,16 +11942,16 @@ mod tests {
1195211942

1195311943
let seed = [42; 32];
1195411944
let network = Network::Testnet;
11955-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
11945+
let keys_provider = TestKeysInterface::new(&seed, network);
1195611946
keys_provider.expect(OnGetShutdownScriptpubkey {
1195711947
returns: non_v0_segwit_shutdown_script.clone(),
1195811948
});
11959-
let logger = test_utils::TestLogger::new();
11949+
let logger = TestLogger::new();
1196011950

1196111951
let secp_ctx = Secp256k1::new();
1196211952
let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1196311953
let config = UserConfig::default();
11964-
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) {
11954+
match OutboundV1Channel::<&TestKeysInterface>::new(&LowerBoundedFeeEstimator::new(&TestFeeEstimator::new(253)), &&keys_provider, &&keys_provider, node_id, &features, 10000000, 100000, 42, &config, 0, 42, None, &logger) {
1196511955
Err(APIError::IncompatibleShutdownScript { script }) => {
1196611956
assert_eq!(script.into_inner(), non_v0_segwit_shutdown_script.into_inner());
1196711957
},
@@ -11975,21 +11965,21 @@ mod tests {
1197511965
#[test]
1197611966
fn test_open_channel_msg_fee() {
1197711967
let original_fee = 253;
11978-
let mut fee_est = TestFeeEstimator{fee_est: original_fee };
11968+
let fee_est = TestFeeEstimator::new(original_fee);
1197911969
let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_est);
1198011970
let secp_ctx = Secp256k1::new();
1198111971
let seed = [42; 32];
1198211972
let network = Network::Testnet;
11983-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
11984-
let logger = test_utils::TestLogger::new();
11973+
let keys_provider = TestKeysInterface::new(&seed, network);
11974+
let logger = TestLogger::new();
1198511975

1198611976
let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1198711977
let config = UserConfig::default();
1198811978
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();
1198911979

1199011980
// Now change the fee so we can check that the fee in the open_channel message is the
1199111981
// same as the old fee.
11992-
fee_est.fee_est = 500;
11982+
*fee_est.sat_per_kw.lock().unwrap() = 500;
1199311983
let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap();
1199411984
assert_eq!(open_channel_msg.common_fields.commitment_feerate_sat_per_1000_weight, original_fee);
1199511985
}
@@ -11998,12 +11988,13 @@ mod tests {
1199811988
fn test_holder_vs_counterparty_dust_limit() {
1199911989
// Test that when calculating the local and remote commitment transaction fees, the correct
1200011990
// dust limits are used.
12001-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
11991+
let test_est = TestFeeEstimator::new(15000);
11992+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
1200211993
let secp_ctx = Secp256k1::new();
1200311994
let seed = [42; 32];
1200411995
let network = Network::Testnet;
12005-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12006-
let logger = test_utils::TestLogger::new();
11996+
let keys_provider = TestKeysInterface::new(&seed, network);
11997+
let logger = TestLogger::new();
1200711998
let best_block = BestBlock::from_network(network);
1200811999

1200912000
// Go through the flow of opening a channel between two nodes, making sure
@@ -12089,12 +12080,13 @@ mod tests {
1208912080
// calculate the real dust limits for HTLCs (i.e. the dust limit given by the counterparty
1209012081
// *plus* the fees paid for the HTLC) they don't swap `HTLC_SUCCESS_TX_WEIGHT` for
1209112082
// `HTLC_TIMEOUT_TX_WEIGHT`, and vice versa.
12092-
let fee_est = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 253 });
12083+
let test_est = TestFeeEstimator::new(253);
12084+
let fee_est = LowerBoundedFeeEstimator::new(&test_est);
1209312085
let secp_ctx = Secp256k1::new();
1209412086
let seed = [42; 32];
1209512087
let network = Network::Testnet;
12096-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12097-
let logger = test_utils::TestLogger::new();
12088+
let keys_provider = TestKeysInterface::new(&seed, network);
12089+
let logger = TestLogger::new();
1209812090

1209912091
let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1210012092
let config = UserConfig::default();
@@ -12133,14 +12125,15 @@ mod tests {
1213312125

1213412126
#[test]
1213512127
fn channel_reestablish_no_updates() {
12136-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
12137-
let logger = test_utils::TestLogger::new();
12128+
let test_est = TestFeeEstimator::new(15000);
12129+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
12130+
let logger = TestLogger::new();
1213812131
let secp_ctx = Secp256k1::new();
1213912132
let seed = [42; 32];
1214012133
let network = Network::Testnet;
1214112134
let best_block = BestBlock::from_network(network);
1214212135
let chain_hash = ChainHash::using_genesis_block(network);
12143-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12136+
let keys_provider = TestKeysInterface::new(&seed, network);
1214412137

1214512138
// Go through the flow of opening a channel between two nodes.
1214612139

@@ -12190,12 +12183,13 @@ mod tests {
1219012183

1219112184
#[test]
1219212185
fn test_configured_holder_max_htlc_value_in_flight() {
12193-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
12194-
let logger = test_utils::TestLogger::new();
12186+
let test_est = TestFeeEstimator::new(15000);
12187+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
12188+
let logger = TestLogger::new();
1219512189
let secp_ctx = Secp256k1::new();
1219612190
let seed = [42; 32];
1219712191
let network = Network::Testnet;
12198-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12192+
let keys_provider = TestKeysInterface::new(&seed, network);
1219912193
let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1220012194
let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
1220112195

@@ -12284,12 +12278,13 @@ mod tests {
1228412278
}
1228512279

1228612280
fn test_self_and_counterparty_channel_reserve(channel_value_satoshis: u64, outbound_selected_channel_reserve_perc: f64, inbound_selected_channel_reserve_perc: f64) {
12287-
let fee_est = LowerBoundedFeeEstimator::new(&TestFeeEstimator { fee_est: 15_000 });
12288-
let logger = test_utils::TestLogger::new();
12281+
let test_est = TestFeeEstimator::new(15000);
12282+
let fee_est = LowerBoundedFeeEstimator::new(&test_est);
12283+
let logger = TestLogger::new();
1228912284
let secp_ctx = Secp256k1::new();
1229012285
let seed = [42; 32];
1229112286
let network = Network::Testnet;
12292-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12287+
let keys_provider = TestKeysInterface::new(&seed, network);
1229312288
let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1229412289
let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
1229512290

@@ -12321,14 +12316,15 @@ mod tests {
1232112316

1232212317
#[test]
1232312318
fn channel_update() {
12324-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
12325-
let logger = test_utils::TestLogger::new();
12319+
let test_est = TestFeeEstimator::new(15000);
12320+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
12321+
let logger = TestLogger::new();
1232612322
let secp_ctx = Secp256k1::new();
1232712323
let seed = [42; 32];
1232812324
let network = Network::Testnet;
1232912325
let best_block = BestBlock::from_network(network);
1233012326
let chain_hash = ChainHash::using_genesis_block(network);
12331-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12327+
let keys_provider = TestKeysInterface::new(&seed, network);
1233212328

1233312329
// Create Node A's channel pointing to Node B's pubkey
1233412330
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
@@ -12398,13 +12394,14 @@ mod tests {
1239812394
fn blinding_point_skimmed_fee_malformed_ser() {
1239912395
// Ensure that channel blinding points, skimmed fees, and malformed HTLCs are (de)serialized
1240012396
// properly.
12401-
let logger = test_utils::TestLogger::new();
12402-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
12397+
let logger = TestLogger::new();
12398+
let test_est = TestFeeEstimator::new(15000);
12399+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
1240312400
let secp_ctx = Secp256k1::new();
1240412401
let seed = [42; 32];
1240512402
let network = Network::Testnet;
1240612403
let best_block = BestBlock::from_network(network);
12407-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
12404+
let keys_provider = TestKeysInterface::new(&seed, network);
1240812405

1240912406
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1241012407
let config = UserConfig::default();
@@ -12543,8 +12540,8 @@ mod tests {
1254312540
use core::str::FromStr;
1254412541

1254512542
// Test vectors from BOLT 3 Appendices C and F (anchors):
12546-
let feeest = TestFeeEstimator{fee_est: 15000};
12547-
let logger : Arc<dyn Logger> = Arc::new(test_utils::TestLogger::new());
12543+
let feeest = TestFeeEstimator::new(15000);
12544+
let logger : Arc<dyn Logger> = Arc::new(TestLogger::new());
1254812545
let secp_ctx = Secp256k1::new();
1254912546

1255012547
let signer = InMemorySigner::new(
@@ -13304,12 +13301,13 @@ mod tests {
1330413301

1330513302
#[test]
1330613303
fn test_zero_conf_channel_type_support() {
13307-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
13304+
let test_est = TestFeeEstimator::new(15000);
13305+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
1330813306
let secp_ctx = Secp256k1::new();
1330913307
let seed = [42; 32];
1331013308
let network = Network::Testnet;
13311-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
13312-
let logger = test_utils::TestLogger::new();
13309+
let keys_provider = TestKeysInterface::new(&seed, network);
13310+
let logger = TestLogger::new();
1331313311

1331413312
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1331513313
let config = UserConfig::default();
@@ -13372,10 +13370,11 @@ mod tests {
1337213370

1337313371
fn do_test_supports_channel_type(config: UserConfig, expected_channel_type: ChannelTypeFeatures) {
1337413372
let secp_ctx = Secp256k1::new();
13375-
let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
13373+
let test_est = TestFeeEstimator::new(15000);
13374+
let fee_estimator = LowerBoundedFeeEstimator::new(&test_est);
1337613375
let network = Network::Testnet;
13377-
let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
13378-
let logger = test_utils::TestLogger::new();
13376+
let keys_provider = TestKeysInterface::new(&[42; 32], network);
13377+
let logger = TestLogger::new();
1337913378

1338013379
let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
1338113380
let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
@@ -13418,10 +13417,11 @@ mod tests {
1341813417
// Tests that if `option_anchors` is being negotiated implicitly through the intersection of
1341913418
// each side's `InitFeatures`, it is rejected.
1342013419
let secp_ctx = Secp256k1::new();
13421-
let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
13420+
let test_est = TestFeeEstimator::new(15000);
13421+
let fee_estimator = LowerBoundedFeeEstimator::new(&test_est);
1342213422
let network = Network::Testnet;
13423-
let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
13424-
let logger = test_utils::TestLogger::new();
13423+
let keys_provider = TestKeysInterface::new(&[42; 32], network);
13424+
let logger = TestLogger::new();
1342513425

1342613426
let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
1342713427
let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
@@ -13459,10 +13459,11 @@ mod tests {
1345913459
// Tests that if `option_anchors` is being negotiated through the `channel_type` feature,
1346013460
// it is rejected.
1346113461
let secp_ctx = Secp256k1::new();
13462-
let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
13462+
let test_est = TestFeeEstimator::new(15000);
13463+
let fee_estimator = LowerBoundedFeeEstimator::new(&test_est);
1346313464
let network = Network::Testnet;
13464-
let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
13465-
let logger = test_utils::TestLogger::new();
13465+
let keys_provider = TestKeysInterface::new(&[42; 32], network);
13466+
let logger = TestLogger::new();
1346613467

1346713468
let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
1346813469
let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
@@ -13525,14 +13526,15 @@ mod tests {
1352513526

1352613527
#[test]
1352713528
fn test_waiting_for_batch() {
13528-
let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
13529-
let logger = test_utils::TestLogger::new();
13529+
let test_est = TestFeeEstimator::new(15000);
13530+
let feeest = LowerBoundedFeeEstimator::new(&test_est);
13531+
let logger = TestLogger::new();
1353013532
let secp_ctx = Secp256k1::new();
1353113533
let seed = [42; 32];
1353213534
let network = Network::Testnet;
1353313535
let best_block = BestBlock::from_network(network);
1353413536
let chain_hash = ChainHash::using_genesis_block(network);
13535-
let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
13537+
let keys_provider = TestKeysInterface::new(&seed, network);
1353613538

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

0 commit comments

Comments
 (0)