mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-02-25 15:20:24 +01:00
Code Issues Projects Releases Packages Wiki Activity

Add logger as parameter in creating ChannelContext

Browse source
This commit is contained in:
Alec Chen 2024-05-30 15:25:29 -05:00
parent 9c2a050a35
commit 1fa67d9434
3 changed files with 40 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
lightning/src/ln/channel.rs
View file

@ -1814,7 +1814,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
Ok(channel_context) Ok(channel_context)
} }
fn new_for_outbound_channel<'a, ES: Deref, F: Deref>( fn new_for_outbound_channel<'a, ES: Deref, F: Deref, L: Deref>(
fee_estimator: &'a LowerBoundedFeeEstimator<F>, fee_estimator: &'a LowerBoundedFeeEstimator<F>,
entropy_source: &'a ES, entropy_source: &'a ES,
signer_provider: &'a SP, signer_provider: &'a SP,
@ -1831,11 +1831,13 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
channel_keys_id: [u8; 32], channel_keys_id: [u8; 32],
holder_signer: <SP::Target as SignerProvider>::EcdsaSigner, holder_signer: <SP::Target as SignerProvider>::EcdsaSigner,
pubkeys: ChannelPublicKeys, pubkeys: ChannelPublicKeys,
_logger: L,
) -> Result<ChannelContext<SP>, APIError> ) -> Result<ChannelContext<SP>, APIError>
where where
ES::Target: EntropySource, ES::Target: EntropySource,
F::Target: FeeEstimator, F::Target: FeeEstimator,
SP::Target: SignerProvider, SP::Target: SignerProvider,
L::Target: Logger,
{ {
// This will be updated with the counterparty contribution if this is a dual-funded channel // This will be updated with the counterparty contribution if this is a dual-funded channel
let channel_value_satoshis = funding_satoshis; let channel_value_satoshis = funding_satoshis;
@ -7525,13 +7527,14 @@ pub(super) struct OutboundV1Channel<SP: Deref> where SP::Target: SignerProvider
} }
impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider { impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
pub fn new<ES: Deref, F: Deref>( pub fn new<ES: Deref, F: Deref, L: Deref>(
fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP, counterparty_node_id: PublicKey, their_features: &InitFeatures, fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP, counterparty_node_id: PublicKey, their_features: &InitFeatures,
channel_value_satoshis: u64, push_msat: u64, user_id: u128, config: &UserConfig, current_chain_height: u32, channel_value_satoshis: u64, push_msat: u64, user_id: u128, config: &UserConfig, current_chain_height: u32,
outbound_scid_alias: u64, temporary_channel_id: Option<ChannelId> outbound_scid_alias: u64, temporary_channel_id: Option<ChannelId>, logger: L
) -> Result<OutboundV1Channel<SP>, APIError> ) -> Result<OutboundV1Channel<SP>, APIError>
where ES::Target: EntropySource, where ES::Target: EntropySource,
F::Target: FeeEstimator F::Target: FeeEstimator,
L::Target: Logger,
{ {
let holder_selected_channel_reserve_satoshis = get_holder_selected_channel_reserve_satoshis(channel_value_satoshis, config); let holder_selected_channel_reserve_satoshis = get_holder_selected_channel_reserve_satoshis(channel_value_satoshis, config);
if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS { if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
@ -7563,6 +7566,7 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
channel_keys_id, channel_keys_id,
holder_signer, holder_signer,
pubkeys, pubkeys,
logger,
)?, )?,
unfunded_context: UnfundedChannelContext { unfunded_channel_age_ticks: 0 } unfunded_context: UnfundedChannelContext { unfunded_channel_age_ticks: 0 }
}; };
@ -8149,14 +8153,15 @@ pub(super) struct OutboundV2Channel<SP: Deref> where SP::Target: SignerProvider
#[cfg(any(dual_funding, splicing))] #[cfg(any(dual_funding, splicing))]
impl<SP: Deref> OutboundV2Channel<SP> where SP::Target: SignerProvider { impl<SP: Deref> OutboundV2Channel<SP> where SP::Target: SignerProvider {
pub fn new<ES: Deref, F: Deref>( pub fn new<ES: Deref, F: Deref, L: Deref>(
fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP, fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP,
counterparty_node_id: PublicKey, their_features: &InitFeatures, funding_satoshis: u64, counterparty_node_id: PublicKey, their_features: &InitFeatures, funding_satoshis: u64,
user_id: u128, config: &UserConfig, current_chain_height: u32, outbound_scid_alias: u64, user_id: u128, config: &UserConfig, current_chain_height: u32, outbound_scid_alias: u64,
funding_confirmation_target: ConfirmationTarget, funding_confirmation_target: ConfirmationTarget, logger: L,
) -> Result<OutboundV2Channel<SP>, APIError> ) -> Result<OutboundV2Channel<SP>, APIError>
where ES::Target: EntropySource, where ES::Target: EntropySource,
F::Target: FeeEstimator, F::Target: FeeEstimator,
L::Target: Logger,
{ {
let channel_keys_id = signer_provider.generate_channel_keys_id(false, funding_satoshis, user_id); let channel_keys_id = signer_provider.generate_channel_keys_id(false, funding_satoshis, user_id);
let holder_signer = signer_provider.derive_channel_signer(funding_satoshis, channel_keys_id); let holder_signer = signer_provider.derive_channel_signer(funding_satoshis, channel_keys_id);
@ -8188,6 +8193,7 @@ impl<SP: Deref> OutboundV2Channel<SP> where SP::Target: SignerProvider {
channel_keys_id, channel_keys_id,
holder_signer, holder_signer,
pubkeys, pubkeys,
logger,
)?, )?,
unfunded_context: UnfundedChannelContext { unfunded_channel_age_ticks: 0 }, unfunded_context: UnfundedChannelContext { unfunded_channel_age_ticks: 0 },
dual_funding_context: DualFundingChannelContext { dual_funding_context: DualFundingChannelContext {
@ -9595,11 +9601,12 @@ mod tests {
keys_provider.expect(OnGetShutdownScriptpubkey { keys_provider.expect(OnGetShutdownScriptpubkey {
returns: non_v0_segwit_shutdown_script.clone(), returns: non_v0_segwit_shutdown_script.clone(),
}); });
let logger = test_utils::TestLogger::new();
let secp_ctx = Secp256k1::new(); let secp_ctx = Secp256k1::new();
let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
let config = UserConfig::default(); let config = UserConfig::default();
match OutboundV1Channel::<&TestKeysInterface>::new(&LowerBoundedFeeEstimator::new(&TestFeeEstimator { fee_est: 253 }), &&keys_provider, &&keys_provider, node_id, &features, 10000000, 100000, 42, &config, 0, 42, None) { 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) {
Err(APIError::IncompatibleShutdownScript { script }) => { Err(APIError::IncompatibleShutdownScript { script }) => {
assert_eq!(script.into_inner(), non_v0_segwit_shutdown_script.into_inner()); assert_eq!(script.into_inner(), non_v0_segwit_shutdown_script.into_inner());
}, },
@ -9619,10 +9626,11 @@ mod tests {
let seed = [42; 32]; let seed = [42; 32];
let network = Network::Testnet; let network = Network::Testnet;
let keys_provider = test_utils::TestKeysInterface::new(&seed, network); let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
let logger = test_utils::TestLogger::new();
let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
let config = UserConfig::default(); let config = UserConfig::default();
let 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).unwrap(); let 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();
// Now change the fee so we can check that the fee in the open_channel message is the // Now change the fee so we can check that the fee in the open_channel message is the
// same as the old fee. // same as the old fee.
@ -9649,7 +9657,7 @@ mod tests {
// Create Node A's channel pointing to Node B's pubkey // Create Node A's channel pointing to Node B's pubkey
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
let config = UserConfig::default(); let config = UserConfig::default();
let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap(); let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger).unwrap();
// Create Node B's channel by receiving Node A's open_channel message // Create Node B's channel by receiving Node A's open_channel message
// Make sure A's dust limit is as we expect. // Make sure A's dust limit is as we expect.
@ -9729,10 +9737,11 @@ mod tests {
let seed = [42; 32]; let seed = [42; 32];
let network = Network::Testnet; let network = Network::Testnet;
let keys_provider = test_utils::TestKeysInterface::new(&seed, network); let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
let logger = test_utils::TestLogger::new();
let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
let config = UserConfig::default(); let config = UserConfig::default();
let mut chan = OutboundV1Channel::<&TestKeysInterface>::new(&fee_est, &&keys_provider, &&keys_provider, node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap(); let mut chan = OutboundV1Channel::<&TestKeysInterface>::new(&fee_est, &&keys_provider, &&keys_provider, node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger).unwrap();
let commitment_tx_fee_0_htlcs = commit_tx_fee_msat(chan.context.feerate_per_kw, 0, chan.context.get_channel_type()); let commitment_tx_fee_0_htlcs = commit_tx_fee_msat(chan.context.feerate_per_kw, 0, chan.context.get_channel_type());
let commitment_tx_fee_1_htlc = commit_tx_fee_msat(chan.context.feerate_per_kw, 1, chan.context.get_channel_type()); let commitment_tx_fee_1_htlc = commit_tx_fee_msat(chan.context.feerate_per_kw, 1, chan.context.get_channel_type());
@ -9781,7 +9790,7 @@ mod tests {
// Create Node A's channel pointing to Node B's pubkey // Create Node A's channel pointing to Node B's pubkey
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
let config = UserConfig::default(); let config = UserConfig::default();
let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap(); let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger).unwrap();
// Create Node B's channel by receiving Node A's open_channel message // Create Node B's channel by receiving Node A's open_channel message
let open_channel_msg = node_a_chan.get_open_channel(chain_hash); let open_channel_msg = node_a_chan.get_open_channel(chain_hash);
@ -9845,12 +9854,12 @@ mod tests {
// Test that `OutboundV1Channel::new` creates a channel with the correct value for // Test that `OutboundV1Channel::new` creates a channel with the correct value for
// `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value, // `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
// which is set to the lower bound + 1 (2%) of the `channel_value`. // which is set to the lower bound + 1 (2%) of the `channel_value`.
let chan_1 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_2_percent), 10000000, 100000, 42, &config_2_percent, 0, 42, None).unwrap(); let chan_1 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_2_percent), 10000000, 100000, 42, &config_2_percent, 0, 42, None, &logger).unwrap();
let chan_1_value_msat = chan_1.context.channel_value_satoshis * 1000; let chan_1_value_msat = chan_1.context.channel_value_satoshis * 1000;
assert_eq!(chan_1.context.holder_max_htlc_value_in_flight_msat, (chan_1_value_msat as f64 * 0.02) as u64); assert_eq!(chan_1.context.holder_max_htlc_value_in_flight_msat, (chan_1_value_msat as f64 * 0.02) as u64);
// Test with the upper bound - 1 of valid values (99%). // Test with the upper bound - 1 of valid values (99%).
let chan_2 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_99_percent), 10000000, 100000, 42, &config_99_percent, 0, 42, None).unwrap(); let chan_2 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_99_percent), 10000000, 100000, 42, &config_99_percent, 0, 42, None, &logger).unwrap();
let chan_2_value_msat = chan_2.context.channel_value_satoshis * 1000; let chan_2_value_msat = chan_2.context.channel_value_satoshis * 1000;
assert_eq!(chan_2.context.holder_max_htlc_value_in_flight_msat, (chan_2_value_msat as f64 * 0.99) as u64); assert_eq!(chan_2.context.holder_max_htlc_value_in_flight_msat, (chan_2_value_msat as f64 * 0.99) as u64);
@ -9870,14 +9879,14 @@ mod tests {
// Test that `OutboundV1Channel::new` uses the lower bound of the configurable percentage values (1%) // Test that `OutboundV1Channel::new` uses the lower bound of the configurable percentage values (1%)
// if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1. // if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
let chan_5 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_0_percent), 10000000, 100000, 42, &config_0_percent, 0, 42, None).unwrap(); let chan_5 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_0_percent), 10000000, 100000, 42, &config_0_percent, 0, 42, None, &logger).unwrap();
let chan_5_value_msat = chan_5.context.channel_value_satoshis * 1000; let chan_5_value_msat = chan_5.context.channel_value_satoshis * 1000;
assert_eq!(chan_5.context.holder_max_htlc_value_in_flight_msat, (chan_5_value_msat as f64 * 0.01) as u64); assert_eq!(chan_5.context.holder_max_htlc_value_in_flight_msat, (chan_5_value_msat as f64 * 0.01) as u64);
// Test that `OutboundV1Channel::new` uses the upper bound of the configurable percentage values // Test that `OutboundV1Channel::new` uses the upper bound of the configurable percentage values
// (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value // (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
// than 100. // than 100.
let chan_6 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_101_percent), 10000000, 100000, 42, &config_101_percent, 0, 42, None).unwrap(); let chan_6 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_101_percent), 10000000, 100000, 42, &config_101_percent, 0, 42, None, &logger).unwrap();
let chan_6_value_msat = chan_6.context.channel_value_satoshis * 1000; let chan_6_value_msat = chan_6.context.channel_value_satoshis * 1000;
assert_eq!(chan_6.context.holder_max_htlc_value_in_flight_msat, chan_6_value_msat); assert_eq!(chan_6.context.holder_max_htlc_value_in_flight_msat, chan_6_value_msat);
@ -9930,7 +9939,7 @@ mod tests {
let mut outbound_node_config = UserConfig::default(); let mut outbound_node_config = UserConfig::default();
outbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (outbound_selected_channel_reserve_perc * 1_000_000.0) as u32; outbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (outbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
let chan = OutboundV1Channel::<&TestKeysInterface>::new(&&fee_est, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&outbound_node_config), channel_value_satoshis, 100_000, 42, &outbound_node_config, 0, 42, None).unwrap(); let chan = OutboundV1Channel::<&TestKeysInterface>::new(&&fee_est, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&outbound_node_config), channel_value_satoshis, 100_000, 42, &outbound_node_config, 0, 42, None, &logger).unwrap();
let expected_outbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.context.channel_value_satoshis as f64 * outbound_selected_channel_reserve_perc) as u64); let expected_outbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.context.channel_value_satoshis as f64 * outbound_selected_channel_reserve_perc) as u64);
assert_eq!(chan.context.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve); assert_eq!(chan.context.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve);
@ -9967,7 +9976,7 @@ mod tests {
// Create Node A's channel pointing to Node B's pubkey // Create Node A's channel pointing to Node B's pubkey
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
let config = UserConfig::default(); let config = UserConfig::default();
let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap(); let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger).unwrap();
// Create Node B's channel by receiving Node A's open_channel message // Create Node B's channel by receiving Node A's open_channel message
// Make sure A's dust limit is as we expect. // Make sure A's dust limit is as we expect.
@ -10044,7 +10053,7 @@ mod tests {
let config = UserConfig::default(); let config = UserConfig::default();
let features = channelmanager::provided_init_features(&config); let features = channelmanager::provided_init_features(&config);
let mut outbound_chan = OutboundV1Channel::<&TestKeysInterface>::new( let mut outbound_chan = OutboundV1Channel::<&TestKeysInterface>::new(
&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &features, 10000000, 100000, 42, &config, 0, 42, None &feeest, &&keys_provider, &&keys_provider, node_b_node_id, &features, 10000000, 100000, 42, &config, 0, 42, None, &logger
).unwrap(); ).unwrap();
let inbound_chan = InboundV1Channel::<&TestKeysInterface>::new( let inbound_chan = InboundV1Channel::<&TestKeysInterface>::new(
&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config), &feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config),
@ -10198,7 +10207,7 @@ mod tests {
let counterparty_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); let counterparty_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
let mut config = UserConfig::default(); let mut config = UserConfig::default();
config.channel_handshake_config.announced_channel = false; config.channel_handshake_config.announced_channel = false;
let mut chan = OutboundV1Channel::<&Keys>::new(&LowerBoundedFeeEstimator::new(&feeest), &&keys_provider, &&keys_provider, counterparty_node_id, &channelmanager::provided_init_features(&config), 10_000_000, 0, 42, &config, 0, 42, None).unwrap(); // Nothing uses their network key in this test let mut chan = OutboundV1Channel::<&Keys>::new(&LowerBoundedFeeEstimator::new(&feeest), &&keys_provider, &&keys_provider, counterparty_node_id, &channelmanager::provided_init_features(&config), 10_000_000, 0, 42, &config, 0, 42, None, &*logger).unwrap(); // Nothing uses their network key in this test
chan.context.holder_dust_limit_satoshis = 546; chan.context.holder_dust_limit_satoshis = 546;
chan.context.counterparty_selected_channel_reserve_satoshis = Some(0); // Filled in in accept_channel chan.context.counterparty_selected_channel_reserve_satoshis = Some(0); // Filled in in accept_channel
@ -10945,7 +10954,7 @@ mod tests {
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
let config = UserConfig::default(); let config = UserConfig::default();
let node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, let node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider,
node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap(); node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger).unwrap();
let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key(); let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key();
channel_type_features.set_zero_conf_required(); channel_type_features.set_zero_conf_required();
@ -10980,7 +10989,7 @@ mod tests {
let channel_a = OutboundV1Channel::<&TestKeysInterface>::new( let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b, &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
&channelmanager::provided_init_features(&UserConfig::default()), 10000000, 100000, 42, &channelmanager::provided_init_features(&UserConfig::default()), 10000000, 100000, 42,
&config, 0, 42, None &config, 0, 42, None, &logger
).unwrap(); ).unwrap();
assert!(!channel_a.context.channel_type.supports_anchors_zero_fee_htlc_tx()); assert!(!channel_a.context.channel_type.supports_anchors_zero_fee_htlc_tx());
@ -10991,7 +11000,7 @@ mod tests {
let channel_a = OutboundV1Channel::<&TestKeysInterface>::new( let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b, &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
None None, &logger
).unwrap(); ).unwrap();
let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network)); let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
@ -11029,7 +11038,7 @@ mod tests {
let channel_a = OutboundV1Channel::<&TestKeysInterface>::new( let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b, &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
None None, &logger
).unwrap(); ).unwrap();
// Set `channel_type` to `None` to force the implicit feature negotiation. // Set `channel_type` to `None` to force the implicit feature negotiation.
@ -11076,7 +11085,7 @@ mod tests {
let channel_a = OutboundV1Channel::<&TestKeysInterface>::new( let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b, &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
None None, &logger
).unwrap(); ).unwrap();
let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network)); let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
@ -11095,7 +11104,7 @@ mod tests {
// LDK. // LDK.
let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new( let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b, &simple_anchors_init, &fee_estimator, &&keys_provider, &&keys_provider, node_id_b, &simple_anchors_init,
10000000, 100000, 42, &config, 0, 42, None 10000000, 100000, 42, &config, 0, 42, None, &logger
).unwrap(); ).unwrap();
let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network)); let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
@ -11145,7 +11154,8 @@ mod tests {
&config, &config,
0, 0,
42, 42,
None None,
&logger
).unwrap(); ).unwrap();
let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network)); let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));

2
lightning/src/ln/channelmanager.rs
View file

@ -3074,7 +3074,7 @@ where
let config = if override_config.is_some() { override_config.as_ref().unwrap() } else { &self.default_configuration }; let config = if override_config.is_some() { override_config.as_ref().unwrap() } else { &self.default_configuration };
match OutboundV1Channel::new(&self.fee_estimator, &self.entropy_source, &self.signer_provider, their_network_key, match OutboundV1Channel::new(&self.fee_estimator, &self.entropy_source, &self.signer_provider, their_network_key,
their_features, channel_value_satoshis, push_msat, user_channel_id, config, their_features, channel_value_satoshis, push_msat, user_channel_id, config,
self.best_block.read().unwrap().height, outbound_scid_alias, temporary_channel_id) self.best_block.read().unwrap().height, outbound_scid_alias, temporary_channel_id, &*self.logger)
{ {
Ok(res) => res, Ok(res) => res,
Err(e) => { Err(e) => {

5
lightning/src/ln/functional_tests.rs
View file

@ -31,7 +31,7 @@ use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, NodeFeatures};
use crate::ln::msgs; use crate::ln::msgs;
use crate::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler, ErrorAction}; use crate::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler, ErrorAction};
use crate::util::test_channel_signer::TestChannelSigner; use crate::util::test_channel_signer::TestChannelSigner;
use crate::util::test_utils::{self, WatchtowerPersister}; use crate::util::test_utils::{self, TestLogger, WatchtowerPersister};
use crate::util::errors::APIError; use crate::util::errors::APIError;
use crate::util::ser::{Writeable, ReadableArgs}; use crate::util::ser::{Writeable, ReadableArgs};
use crate::util::string::UntrustedString; use crate::util::string::UntrustedString;
@ -7244,11 +7244,12 @@ fn test_user_configurable_csv_delay() {
let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &user_cfgs); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &user_cfgs);
let nodes = create_network(2, &node_cfgs, &node_chanmgrs); let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
let logger = TestLogger::new();
// We test config.our_to_self > BREAKDOWN_TIMEOUT is enforced in OutboundV1Channel::new() // We test config.our_to_self > BREAKDOWN_TIMEOUT is enforced in OutboundV1Channel::new()
if let Err(error) = OutboundV1Channel::new(&LowerBoundedFeeEstimator::new(&test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) }), if let Err(error) = OutboundV1Channel::new(&LowerBoundedFeeEstimator::new(&test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) }),
&nodes[0].keys_manager, &nodes[0].keys_manager, nodes[1].node.get_our_node_id(), &nodes[1].node.init_features(), 1000000, 1000000, 0, &nodes[0].keys_manager, &nodes[0].keys_manager, nodes[1].node.get_our_node_id(), &nodes[1].node.init_features(), 1000000, 1000000, 0,
&low_our_to_self_config, 0, 42, None) &low_our_to_self_config, 0, 42, None, &logger)
{ {
match error { match error {
APIError::APIMisuseError { err } => { assert!(regex::Regex::new(r"Configured with an unreasonable our_to_self_delay \(\d+\) putting user funds at risks").unwrap().is_match(err.as_str())); }, APIError::APIMisuseError { err } => { assert!(regex::Regex::new(r"Configured with an unreasonable our_to_self_delay \(\d+\) putting user funds at risks").unwrap().is_match(err.as_str())); },