@@ -8252,6 +8252,10 @@ impl<SP: Deref> Channel<SP> where
8252
8252
pub(super) struct OutboundV1Channel<SP: Deref> where SP::Target: SignerProvider {
8253
8253
pub context: ChannelContext<SP>,
8254
8254
pub unfunded_context: UnfundedChannelContext,
8255
+ /// We tried to send an `open_channel` message but our commitment point wasn't ready.
8256
+ /// This flag tells us we need to send it when we are retried once the
8257
+ /// commitment point is ready.
8258
+ pub signer_pending_open_channel: bool,
8255
8259
}
8256
8260
8257
8261
impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
@@ -8300,7 +8304,9 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
8300
8304
holder_commitment_point: HolderCommitmentPoint::new(&context.holder_signer, &context.secp_ctx),
8301
8305
};
8302
8306
8303
- let chan = Self { context, unfunded_context };
8307
+ // We initialize `signer_pending_open_channel` to false, and leave setting the flag
8308
+ // for when we try to generate the open_channel message.
8309
+ let chan = Self { context, unfunded_context, signer_pending_open_channel: false };
8304
8310
Ok(chan)
8305
8311
}
8306
8312
@@ -8395,14 +8401,15 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
8395
8401
/// If we receive an error message, it may only be a rejection of the channel type we tried,
8396
8402
/// not of our ability to open any channel at all. Thus, on error, we should first call this
8397
8403
/// and see if we get a new `OpenChannel` message, otherwise the channel is failed.
8398
- pub(crate) fn maybe_handle_error_without_close<F: Deref>(
8399
- &mut self, chain_hash: ChainHash, fee_estimator: &LowerBoundedFeeEstimator<F>
8404
+ pub(crate) fn maybe_handle_error_without_close<F: Deref, L: Deref >(
8405
+ &mut self, chain_hash: ChainHash, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
8400
8406
) -> Result<msgs::OpenChannel, ()>
8401
8407
where
8402
- F::Target: FeeEstimator
8408
+ F::Target: FeeEstimator,
8409
+ L::Target: Logger,
8403
8410
{
8404
8411
self.context.maybe_downgrade_channel_features(fee_estimator)?;
8405
- Ok( self.get_open_channel(chain_hash))
8412
+ self.get_open_channel(chain_hash, logger).ok_or(( ))
8406
8413
}
8407
8414
8408
8415
/// Returns true if we can resume the channel by sending the [`msgs::OpenChannel`] again.
@@ -8411,7 +8418,9 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
8411
8418
self.unfunded_context.transaction_number() == INITIAL_COMMITMENT_NUMBER
8412
8419
}
8413
8420
8414
- pub fn get_open_channel(&self, chain_hash: ChainHash) -> msgs::OpenChannel {
8421
+ pub fn get_open_channel<L: Deref>(
8422
+ &mut self, chain_hash: ChainHash, _logger: &L
8423
+ ) -> Option<msgs::OpenChannel> where L::Target: Logger {
8415
8424
if !self.context.is_outbound() {
8416
8425
panic!("Tried to open a channel for an inbound channel?");
8417
8426
}
@@ -8423,13 +8432,25 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
8423
8432
panic!("Tried to send an open_channel for a channel that has already advanced");
8424
8433
}
8425
8434
8426
- debug_assert!(self.unfunded_context.holder_commitment_point
8427
- .map(|point| point.is_available()).unwrap_or(false));
8428
- let first_per_commitment_point = self.unfunded_context.holder_commitment_point
8429
- .expect("TODO: Handle holder_commitment_point not being set").current_point();
8435
+ let first_per_commitment_point = match self.unfunded_context.holder_commitment_point {
8436
+ Some(holder_commitment_point) if holder_commitment_point.is_available() => {
8437
+ self.signer_pending_open_channel = false;
8438
+ holder_commitment_point.current_point()
8439
+ },
8440
+ _ => {
8441
+ #[cfg(not(async_signing))] {
8442
+ panic!("Failed getting commitment point for open_channel message");
8443
+ }
8444
+ #[cfg(async_signing)] {
8445
+ log_trace!(_logger, "Unable to generate open_channel message, waiting for commitment point");
8446
+ self.signer_pending_open_channel = true;
8447
+ return None;
8448
+ }
8449
+ }
8450
+ };
8430
8451
let keys = self.context.get_holder_pubkeys();
8431
8452
8432
- msgs::OpenChannel {
8453
+ Some( msgs::OpenChannel {
8433
8454
common_fields: msgs::CommonOpenChannelFields {
8434
8455
chain_hash,
8435
8456
temporary_channel_id: self.context.channel_id,
@@ -8455,7 +8476,7 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
8455
8476
},
8456
8477
push_msat: self.context.channel_value_satoshis * 1000 - self.context.value_to_self_msat,
8457
8478
channel_reserve_satoshis: self.context.holder_selected_channel_reserve_satoshis,
8458
- }
8479
+ })
8459
8480
}
8460
8481
8461
8482
// Message handlers
@@ -8512,11 +8533,29 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
8512
8533
/// Indicates that the signer may have some signatures for us, so we should retry if we're
8513
8534
/// blocked.
8514
8535
#[cfg(async_signing)]
8515
- pub fn signer_maybe_unblocked<L: Deref>(&mut self, logger: &L) -> Option<msgs::FundingCreated> where L::Target: Logger {
8516
- if self.context.signer_pending_funding && self.context.is_outbound() {
8517
- log_trace!(logger, "Signer unblocked a funding_created");
8536
+ pub fn signer_maybe_unblocked<L: Deref>(
8537
+ &mut self, chain_hash: ChainHash, logger: &L
8538
+ ) -> (Option<msgs::OpenChannel>, Option<msgs::FundingCreated>) where L::Target: Logger {
8539
+ // If we were pending a commitment point, retry the signer and advance to an
8540
+ // available state.
8541
+ if self.unfunded_context.holder_commitment_point.is_none() {
8542
+ self.unfunded_context.holder_commitment_point = HolderCommitmentPoint::new(&self.context.holder_signer, &self.context.secp_ctx);
8543
+ }
8544
+ if let Some(ref mut point) = self.unfunded_context.holder_commitment_point {
8545
+ if !point.is_available() {
8546
+ point.try_resolve_pending(&self.context.holder_signer, &self.context.secp_ctx, logger);
8547
+ }
8548
+ }
8549
+ let open_channel = if self.signer_pending_open_channel {
8550
+ log_trace!(logger, "Attempting to generate open_channel...");
8551
+ self.get_open_channel(chain_hash, logger)
8552
+ } else { None };
8553
+ let funding_created = if self.context.signer_pending_funding && self.context.is_outbound() {
8554
+ log_trace!(logger, "Attempting to generate pending funding created...");
8555
+ self.context.signer_pending_funding = false;
8518
8556
self.get_funding_created_msg(logger)
8519
- } else { None }
8557
+ } else { None };
8558
+ (open_channel, funding_created)
8520
8559
}
8521
8560
}
8522
8561
@@ -10327,12 +10366,12 @@ mod tests {
10327
10366
10328
10367
let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
10329
10368
let config = UserConfig::default();
10330
- 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();
10369
+ 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();
10331
10370
10332
10371
// Now change the fee so we can check that the fee in the open_channel message is the
10333
10372
// same as the old fee.
10334
10373
fee_est.fee_est = 500;
10335
- let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
10374
+ let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
10336
10375
assert_eq!(open_channel_msg.common_fields.commitment_feerate_sat_per_1000_weight, original_fee);
10337
10376
}
10338
10377
@@ -10358,7 +10397,7 @@ mod tests {
10358
10397
10359
10398
// Create Node B's channel by receiving Node A's open_channel message
10360
10399
// Make sure A's dust limit is as we expect.
10361
- let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
10400
+ let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
10362
10401
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
10363
10402
let 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();
10364
10403
@@ -10490,7 +10529,7 @@ mod tests {
10490
10529
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();
10491
10530
10492
10531
// Create Node B's channel by receiving Node A's open_channel message
10493
- let open_channel_msg = node_a_chan.get_open_channel(chain_hash);
10532
+ let open_channel_msg = node_a_chan.get_open_channel(chain_hash, &&logger).unwrap( );
10494
10533
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
10495
10534
let 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();
10496
10535
@@ -10551,7 +10590,7 @@ mod tests {
10551
10590
// Test that `OutboundV1Channel::new` creates a channel with the correct value for
10552
10591
// `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
10553
10592
// which is set to the lower bound + 1 (2%) of the `channel_value`.
10554
- 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();
10593
+ 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();
10555
10594
let chan_1_value_msat = chan_1.context.channel_value_satoshis * 1000;
10556
10595
assert_eq!(chan_1.context.holder_max_htlc_value_in_flight_msat, (chan_1_value_msat as f64 * 0.02) as u64);
10557
10596
@@ -10560,7 +10599,7 @@ mod tests {
10560
10599
let chan_2_value_msat = chan_2.context.channel_value_satoshis * 1000;
10561
10600
assert_eq!(chan_2.context.holder_max_htlc_value_in_flight_msat, (chan_2_value_msat as f64 * 0.99) as u64);
10562
10601
10563
- let chan_1_open_channel_msg = chan_1.get_open_channel(ChainHash::using_genesis_block(network));
10602
+ let chan_1_open_channel_msg = chan_1.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
10564
10603
10565
10604
// Test that `InboundV1Channel::new` creates a channel with the correct value for
10566
10605
// `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
@@ -10636,12 +10675,12 @@ mod tests {
10636
10675
10637
10676
let mut outbound_node_config = UserConfig::default();
10638
10677
outbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (outbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
10639
- 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();
10678
+ 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();
10640
10679
10641
10680
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);
10642
10681
assert_eq!(chan.context.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve);
10643
10682
10644
- let chan_open_channel_msg = chan.get_open_channel(ChainHash::using_genesis_block(network));
10683
+ let chan_open_channel_msg = chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
10645
10684
let mut inbound_node_config = UserConfig::default();
10646
10685
inbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (inbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
10647
10686
@@ -10677,7 +10716,7 @@ mod tests {
10677
10716
10678
10717
// Create Node B's channel by receiving Node A's open_channel message
10679
10718
// Make sure A's dust limit is as we expect.
10680
- let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
10719
+ let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
10681
10720
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
10682
10721
let 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();
10683
10722
@@ -10754,7 +10793,7 @@ mod tests {
10754
10793
).unwrap();
10755
10794
let inbound_chan = InboundV1Channel::<&TestKeysInterface>::new(
10756
10795
&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config),
10757
- &features, &outbound_chan.get_open_channel(ChainHash::using_genesis_block(network)), 7, &config, 0, &&logger, false
10796
+ &features, &outbound_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( ), 7, &config, 0, &&logger, false
10758
10797
).unwrap();
10759
10798
outbound_chan.accept_channel(&inbound_chan.get_accept_channel_message(), &config.channel_handshake_limits, &features).unwrap();
10760
10799
let tx = Transaction { version: Version::ONE, lock_time: LockTime::ZERO, input: Vec::new(), output: vec![TxOut {
@@ -11652,13 +11691,13 @@ mod tests {
11652
11691
11653
11692
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
11654
11693
let config = UserConfig::default();
11655
- let node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider,
11694
+ let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider,
11656
11695
node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger).unwrap();
11657
11696
11658
11697
let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key();
11659
11698
channel_type_features.set_zero_conf_required();
11660
11699
11661
- let mut open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
11700
+ let mut open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
11662
11701
open_channel_msg.common_fields.channel_type = Some(channel_type_features);
11663
11702
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
11664
11703
let res = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider,
@@ -11696,13 +11735,13 @@ mod tests {
11696
11735
expected_channel_type.set_static_remote_key_required();
11697
11736
expected_channel_type.set_anchors_zero_fee_htlc_tx_required();
11698
11737
11699
- let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
11738
+ let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
11700
11739
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
11701
11740
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
11702
11741
None, &logger
11703
11742
).unwrap();
11704
11743
11705
- let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
11744
+ let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
11706
11745
let channel_b = InboundV1Channel::<&TestKeysInterface>::new(
11707
11746
&fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
11708
11747
&channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config),
@@ -11734,14 +11773,14 @@ mod tests {
11734
11773
let raw_init_features = static_remote_key_required | simple_anchors_required;
11735
11774
let init_features_with_simple_anchors = InitFeatures::from_le_bytes(raw_init_features.to_le_bytes().to_vec());
11736
11775
11737
- let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
11776
+ let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
11738
11777
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
11739
11778
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
11740
11779
None, &logger
11741
11780
).unwrap();
11742
11781
11743
11782
// Set `channel_type` to `None` to force the implicit feature negotiation.
11744
- let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
11783
+ let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
11745
11784
open_channel_msg.common_fields.channel_type = None;
11746
11785
11747
11786
// Since A supports both `static_remote_key` and `option_anchors`, but B only accepts
@@ -11781,13 +11820,13 @@ mod tests {
11781
11820
// First, we'll try to open a channel between A and B where A requests a channel type for
11782
11821
// the original `option_anchors` feature (non zero fee htlc tx). This should be rejected by
11783
11822
// B as it's not supported by LDK.
11784
- let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
11823
+ let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
11785
11824
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
11786
11825
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
11787
11826
None, &logger
11788
11827
).unwrap();
11789
11828
11790
- let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
11829
+ let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
11791
11830
open_channel_msg.common_fields.channel_type = Some(simple_anchors_channel_type.clone());
11792
11831
11793
11832
let res = InboundV1Channel::<&TestKeysInterface>::new(
@@ -11806,7 +11845,7 @@ mod tests {
11806
11845
10000000, 100000, 42, &config, 0, 42, None, &logger
11807
11846
).unwrap();
11808
11847
11809
- let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
11848
+ let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
11810
11849
11811
11850
let channel_b = InboundV1Channel::<&TestKeysInterface>::new(
11812
11851
&fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
@@ -11857,7 +11896,7 @@ mod tests {
11857
11896
&logger
11858
11897
).unwrap();
11859
11898
11860
- let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
11899
+ let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap( );
11861
11900
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
11862
11901
let node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(
11863
11902
&feeest,
0 commit comments