@@ -7425,14 +7425,15 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
7425
7425
/// If we receive an error message, it may only be a rejection of the channel type we tried,
7426
7426
/// not of our ability to open any channel at all. Thus, on error, we should first call this
7427
7427
/// and see if we get a new `OpenChannel` message, otherwise the channel is failed.
7428
- pub(crate) fn maybe_handle_error_without_close<F: Deref>(
7429
- &mut self, chain_hash: ChainHash, fee_estimator: &LowerBoundedFeeEstimator<F>
7428
+ pub(crate) fn maybe_handle_error_without_close<F: Deref, L: Deref >(
7429
+ &mut self, chain_hash: ChainHash, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
7430
7430
) -> Result<msgs::OpenChannel, ()>
7431
7431
where
7432
- F::Target: FeeEstimator
7432
+ F::Target: FeeEstimator,
7433
+ L::Target: Logger,
7433
7434
{
7434
7435
self.context.maybe_downgrade_channel_features(fee_estimator)?;
7435
- Ok( self.get_open_channel(chain_hash))
7436
+ self.get_open_channel(chain_hash, logger).ok_or(( ))
7436
7437
}
7437
7438
7438
7439
/// Returns true if we can resume the channel by sending the [`msgs::OpenChannel`] again.
@@ -7441,7 +7442,9 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
7441
7442
self.context.holder_commitment_point.transaction_number() == INITIAL_COMMITMENT_NUMBER
7442
7443
}
7443
7444
7444
- pub fn get_open_channel(&self, chain_hash: ChainHash) -> msgs::OpenChannel {
7445
+ pub fn get_open_channel<L: Deref>(&mut self, chain_hash: ChainHash, logger: &L) -> Option<msgs::OpenChannel>
7446
+ where L::Target: Logger
7447
+ {
7445
7448
if !self.context.is_outbound() {
7446
7449
panic!("Tried to open a channel for an inbound channel?");
7447
7450
}
@@ -7453,11 +7456,20 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
7453
7456
panic!("Tried to send an open_channel for a channel that has already advanced");
7454
7457
}
7455
7458
7456
- debug_assert!(self.context.holder_commitment_point.is_available());
7457
- let first_per_commitment_point = self.context.holder_commitment_point.current_point().expect("TODO");
7459
+ // Note: another option here is to make commitment point a parameter of this function
7460
+ // and make a helper method get_point_for_open_channel to check + set signer_pending_open_channel
7461
+ // and call that right before anytime we call this function, so this function can remain
7462
+ // side-effect free.
7463
+ let first_per_commitment_point = if let Some(point) = self.context.holder_commitment_point.current_point() {
7464
+ point
7465
+ } else {
7466
+ log_trace!(logger, "Unable to generate open_channel message, waiting for commitment point");
7467
+ self.signer_pending_open_channel = true;
7468
+ return None;
7469
+ };
7458
7470
let keys = self.context.get_holder_pubkeys();
7459
7471
7460
- msgs::OpenChannel {
7472
+ Some( msgs::OpenChannel {
7461
7473
common_fields: msgs::CommonOpenChannelFields {
7462
7474
chain_hash,
7463
7475
temporary_channel_id: self.context.channel_id,
@@ -7483,7 +7495,7 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
7483
7495
},
7484
7496
push_msat: self.context.channel_value_satoshis * 1000 - self.context.value_to_self_msat,
7485
7497
channel_reserve_satoshis: self.context.holder_selected_channel_reserve_satoshis,
7486
- }
7498
+ })
7487
7499
}
7488
7500
7489
7501
// Message handlers
@@ -9494,12 +9506,12 @@ mod tests {
9494
9506
9495
9507
let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
9496
9508
let config = UserConfig::default();
9497
- 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();
9509
+ 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();
9498
9510
9499
9511
// Now change the fee so we can check that the fee in the open_channel message is the
9500
9512
// same as the old fee.
9501
9513
fee_est.fee_est = 500;
9502
- let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
9514
+ let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
9503
9515
assert_eq!(open_channel_msg.common_fields.commitment_feerate_sat_per_1000_weight, original_fee);
9504
9516
}
9505
9517
@@ -9525,7 +9537,7 @@ mod tests {
9525
9537
9526
9538
// Create Node B's channel by receiving Node A's open_channel message
9527
9539
// Make sure A's dust limit is as we expect.
9528
- let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
9540
+ let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
9529
9541
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
9530
9542
let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false).unwrap();
9531
9543
@@ -9657,7 +9669,7 @@ mod tests {
9657
9669
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();
9658
9670
9659
9671
// Create Node B's channel by receiving Node A's open_channel message
9660
- let open_channel_msg = node_a_chan.get_open_channel(chain_hash);
9672
+ let open_channel_msg = node_a_chan.get_open_channel(chain_hash, &&logger).unwrap( );
9661
9673
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
9662
9674
let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false).unwrap();
9663
9675
@@ -9718,7 +9730,7 @@ mod tests {
9718
9730
// Test that `OutboundV1Channel::new` creates a channel with the correct value for
9719
9731
// `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
9720
9732
// which is set to the lower bound + 1 (2%) of the `channel_value`.
9721
- 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();
9733
+ let mut 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();
9722
9734
let chan_1_value_msat = chan_1.context.channel_value_satoshis * 1000;
9723
9735
assert_eq!(chan_1.context.holder_max_htlc_value_in_flight_msat, (chan_1_value_msat as f64 * 0.02) as u64);
9724
9736
@@ -9727,7 +9739,7 @@ mod tests {
9727
9739
let chan_2_value_msat = chan_2.context.channel_value_satoshis * 1000;
9728
9740
assert_eq!(chan_2.context.holder_max_htlc_value_in_flight_msat, (chan_2_value_msat as f64 * 0.99) as u64);
9729
9741
9730
- let chan_1_open_channel_msg = chan_1.get_open_channel(ChainHash::using_genesis_block(network));
9742
+ let chan_1_open_channel_msg = chan_1.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
9731
9743
9732
9744
// Test that `InboundV1Channel::new` creates a channel with the correct value for
9733
9745
// `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
@@ -9803,12 +9815,12 @@ mod tests {
9803
9815
9804
9816
let mut outbound_node_config = UserConfig::default();
9805
9817
outbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (outbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
9806
- 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();
9818
+ let mut 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();
9807
9819
9808
9820
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);
9809
9821
assert_eq!(chan.context.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve);
9810
9822
9811
- let chan_open_channel_msg = chan.get_open_channel(ChainHash::using_genesis_block(network));
9823
+ let chan_open_channel_msg = chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
9812
9824
let mut inbound_node_config = UserConfig::default();
9813
9825
inbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (inbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
9814
9826
@@ -9844,7 +9856,7 @@ mod tests {
9844
9856
9845
9857
// Create Node B's channel by receiving Node A's open_channel message
9846
9858
// Make sure A's dust limit is as we expect.
9847
- let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
9859
+ let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
9848
9860
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
9849
9861
let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false).unwrap();
9850
9862
@@ -9920,7 +9932,7 @@ mod tests {
9920
9932
).unwrap();
9921
9933
let inbound_chan = InboundV1Channel::<&TestKeysInterface>::new(
9922
9934
&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config),
9923
- &features, &outbound_chan.get_open_channel(ChainHash::using_genesis_block(network)), 7, &config, 0, &&logger, false
9935
+ &features, &outbound_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( ), 7, &config, 0, &&logger, false
9924
9936
).unwrap();
9925
9937
outbound_chan.accept_channel(&inbound_chan.get_accept_channel_message(), &config.channel_handshake_limits, &features).unwrap();
9926
9938
let tx = Transaction { version: Version::ONE, lock_time: LockTime::ZERO, input: Vec::new(), output: vec![TxOut {
@@ -10816,13 +10828,13 @@ mod tests {
10816
10828
10817
10829
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
10818
10830
let config = UserConfig::default();
10819
- let node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider,
10831
+ let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider,
10820
10832
node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &&logger).unwrap();
10821
10833
10822
10834
let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key();
10823
10835
channel_type_features.set_zero_conf_required();
10824
10836
10825
- let mut open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
10837
+ let mut open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
10826
10838
open_channel_msg.common_fields.channel_type = Some(channel_type_features);
10827
10839
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
10828
10840
let res = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider,
@@ -10860,13 +10872,13 @@ mod tests {
10860
10872
expected_channel_type.set_static_remote_key_required();
10861
10873
expected_channel_type.set_anchors_zero_fee_htlc_tx_required();
10862
10874
10863
- let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10875
+ let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10864
10876
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
10865
10877
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
10866
10878
None, &&logger
10867
10879
).unwrap();
10868
10880
10869
- let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
10881
+ let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
10870
10882
let channel_b = InboundV1Channel::<&TestKeysInterface>::new(
10871
10883
&fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
10872
10884
&channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config),
@@ -10898,14 +10910,14 @@ mod tests {
10898
10910
let raw_init_features = static_remote_key_required | simple_anchors_required;
10899
10911
let init_features_with_simple_anchors = InitFeatures::from_le_bytes(raw_init_features.to_le_bytes().to_vec());
10900
10912
10901
- let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10913
+ let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10902
10914
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
10903
10915
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
10904
10916
None, &&logger
10905
10917
).unwrap();
10906
10918
10907
10919
// Set `channel_type` to `None` to force the implicit feature negotiation.
10908
- let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
10920
+ let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
10909
10921
open_channel_msg.common_fields.channel_type = None;
10910
10922
10911
10923
// Since A supports both `static_remote_key` and `option_anchors`, but B only accepts
@@ -10945,13 +10957,13 @@ mod tests {
10945
10957
// First, we'll try to open a channel between A and B where A requests a channel type for
10946
10958
// the original `option_anchors` feature (non zero fee htlc tx). This should be rejected by
10947
10959
// B as it's not supported by LDK.
10948
- let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10960
+ let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10949
10961
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
10950
10962
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
10951
10963
None, &&logger
10952
10964
).unwrap();
10953
10965
10954
- let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
10966
+ let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
10955
10967
open_channel_msg.common_fields.channel_type = Some(simple_anchors_channel_type.clone());
10956
10968
10957
10969
let res = InboundV1Channel::<&TestKeysInterface>::new(
@@ -10970,7 +10982,7 @@ mod tests {
10970
10982
10000000, 100000, 42, &config, 0, 42, None, &&logger
10971
10983
).unwrap();
10972
10984
10973
- let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
10985
+ let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
10974
10986
10975
10987
let channel_b = InboundV1Channel::<&TestKeysInterface>::new(
10976
10988
&fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
@@ -11021,7 +11033,7 @@ mod tests {
11021
11033
&&logger
11022
11034
).unwrap();
11023
11035
11024
- let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
11036
+ let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
11025
11037
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
11026
11038
let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(
11027
11039
&feeest,
0 commit comments