Skip to content

Commit 84a7762

Browse files
committed
Handle fallible commitment point for open_channel message
In the event that a signer cannot provide a commitment point immediately, we set a flag to remember we're waiting for this before we can send `open_channel`. We make sure to get the first two commitment points, so when we advance commitments, we always have a commitment point available. When initializing a context, we set the `signer_pending_open_channel` flag to false, and leave setting this flag for where we attempt to generate a message. When checking to send messages when a signer is unblocked, we must handle both when we haven't gotten any commitment point, as well as when we've gotten the first but not the second point.
1 parent 01016da commit 84a7762

File tree

2 files changed

+101
-48
lines changed

2 files changed

+101
-48
lines changed

lightning/src/ln/channel.rs

Lines changed: 75 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -8252,6 +8252,10 @@ impl<SP: Deref> Channel<SP> where
82528252
pub(super) struct OutboundV1Channel<SP: Deref> where SP::Target: SignerProvider {
82538253
pub context: ChannelContext<SP>,
82548254
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,
82558259
}
82568260

82578261
impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
@@ -8300,7 +8304,9 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
83008304
holder_commitment_point: HolderCommitmentPoint::new(&context.holder_signer, &context.secp_ctx),
83018305
};
83028306

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 };
83048310
Ok(chan)
83058311
}
83068312

@@ -8395,14 +8401,15 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
83958401
/// If we receive an error message, it may only be a rejection of the channel type we tried,
83968402
/// not of our ability to open any channel at all. Thus, on error, we should first call this
83978403
/// 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
84008406
) -> Result<msgs::OpenChannel, ()>
84018407
where
8402-
F::Target: FeeEstimator
8408+
F::Target: FeeEstimator,
8409+
L::Target: Logger,
84038410
{
84048411
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(())
84068413
}
84078414

84088415
/// 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 {
84118418
self.unfunded_context.transaction_number() == INITIAL_COMMITMENT_NUMBER
84128419
}
84138420

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 {
84158424
if !self.context.is_outbound() {
84168425
panic!("Tried to open a channel for an inbound channel?");
84178426
}
@@ -8423,13 +8432,25 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
84238432
panic!("Tried to send an open_channel for a channel that has already advanced");
84248433
}
84258434

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+
};
84308451
let keys = self.context.get_holder_pubkeys();
84318452

8432-
msgs::OpenChannel {
8453+
Some(msgs::OpenChannel {
84338454
common_fields: msgs::CommonOpenChannelFields {
84348455
chain_hash,
84358456
temporary_channel_id: self.context.channel_id,
@@ -8455,7 +8476,7 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
84558476
},
84568477
push_msat: self.context.channel_value_satoshis * 1000 - self.context.value_to_self_msat,
84578478
channel_reserve_satoshis: self.context.holder_selected_channel_reserve_satoshis,
8458-
}
8479+
})
84598480
}
84608481

84618482
// Message handlers
@@ -8512,11 +8533,29 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
85128533
/// Indicates that the signer may have some signatures for us, so we should retry if we're
85138534
/// blocked.
85148535
#[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;
85188556
self.get_funding_created_msg(logger)
8519-
} else { None }
8557+
} else { None };
8558+
(open_channel, funding_created)
85208559
}
85218560
}
85228561

@@ -10327,12 +10366,12 @@ mod tests {
1032710366

1032810367
let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1032910368
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();
1033110370

1033210371
// Now change the fee so we can check that the fee in the open_channel message is the
1033310372
// same as the old fee.
1033410373
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();
1033610375
assert_eq!(open_channel_msg.common_fields.commitment_feerate_sat_per_1000_weight, original_fee);
1033710376
}
1033810377

@@ -10358,7 +10397,7 @@ mod tests {
1035810397

1035910398
// Create Node B's channel by receiving Node A's open_channel message
1036010399
// 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();
1036210401
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
1036310402
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();
1036410403

@@ -10490,7 +10529,7 @@ mod tests {
1049010529
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();
1049110530

1049210531
// 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();
1049410533
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
1049510534
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();
1049610535

@@ -10551,7 +10590,7 @@ mod tests {
1055110590
// Test that `OutboundV1Channel::new` creates a channel with the correct value for
1055210591
// `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
1055310592
// 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();
1055510594
let chan_1_value_msat = chan_1.context.channel_value_satoshis * 1000;
1055610595
assert_eq!(chan_1.context.holder_max_htlc_value_in_flight_msat, (chan_1_value_msat as f64 * 0.02) as u64);
1055710596

@@ -10560,7 +10599,7 @@ mod tests {
1056010599
let chan_2_value_msat = chan_2.context.channel_value_satoshis * 1000;
1056110600
assert_eq!(chan_2.context.holder_max_htlc_value_in_flight_msat, (chan_2_value_msat as f64 * 0.99) as u64);
1056210601

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();
1056410603

1056510604
// Test that `InboundV1Channel::new` creates a channel with the correct value for
1056610605
// `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
@@ -10636,12 +10675,12 @@ mod tests {
1063610675

1063710676
let mut outbound_node_config = UserConfig::default();
1063810677
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();
1064010679

1064110680
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);
1064210681
assert_eq!(chan.context.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve);
1064310682

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();
1064510684
let mut inbound_node_config = UserConfig::default();
1064610685
inbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (inbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
1064710686

@@ -10677,7 +10716,7 @@ mod tests {
1067710716

1067810717
// Create Node B's channel by receiving Node A's open_channel message
1067910718
// 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();
1068110720
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
1068210721
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();
1068310722

@@ -10754,7 +10793,7 @@ mod tests {
1075410793
).unwrap();
1075510794
let inbound_chan = InboundV1Channel::<&TestKeysInterface>::new(
1075610795
&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
1075810797
).unwrap();
1075910798
outbound_chan.accept_channel(&inbound_chan.get_accept_channel_message(), &config.channel_handshake_limits, &features).unwrap();
1076010799
let tx = Transaction { version: Version::ONE, lock_time: LockTime::ZERO, input: Vec::new(), output: vec![TxOut {
@@ -11652,13 +11691,13 @@ mod tests {
1165211691

1165311692
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
1165411693
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,
1165611695
node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger).unwrap();
1165711696

1165811697
let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key();
1165911698
channel_type_features.set_zero_conf_required();
1166011699

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();
1166211701
open_channel_msg.common_fields.channel_type = Some(channel_type_features);
1166311702
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
1166411703
let res = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider,
@@ -11696,13 +11735,13 @@ mod tests {
1169611735
expected_channel_type.set_static_remote_key_required();
1169711736
expected_channel_type.set_anchors_zero_fee_htlc_tx_required();
1169811737

11699-
let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
11738+
let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
1170011739
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
1170111740
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
1170211741
None, &logger
1170311742
).unwrap();
1170411743

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();
1170611745
let channel_b = InboundV1Channel::<&TestKeysInterface>::new(
1170711746
&fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
1170811747
&channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config),
@@ -11734,14 +11773,14 @@ mod tests {
1173411773
let raw_init_features = static_remote_key_required | simple_anchors_required;
1173511774
let init_features_with_simple_anchors = InitFeatures::from_le_bytes(raw_init_features.to_le_bytes().to_vec());
1173611775

11737-
let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
11776+
let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
1173811777
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
1173911778
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
1174011779
None, &logger
1174111780
).unwrap();
1174211781

1174311782
// 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();
1174511784
open_channel_msg.common_fields.channel_type = None;
1174611785

1174711786
// Since A supports both `static_remote_key` and `option_anchors`, but B only accepts
@@ -11781,13 +11820,13 @@ mod tests {
1178111820
// First, we'll try to open a channel between A and B where A requests a channel type for
1178211821
// the original `option_anchors` feature (non zero fee htlc tx). This should be rejected by
1178311822
// B as it's not supported by LDK.
11784-
let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
11823+
let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
1178511824
&fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
1178611825
&channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
1178711826
None, &logger
1178811827
).unwrap();
1178911828

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();
1179111830
open_channel_msg.common_fields.channel_type = Some(simple_anchors_channel_type.clone());
1179211831

1179311832
let res = InboundV1Channel::<&TestKeysInterface>::new(
@@ -11806,7 +11845,7 @@ mod tests {
1180611845
10000000, 100000, 42, &config, 0, 42, None, &logger
1180711846
).unwrap();
1180811847

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();
1181011849

1181111850
let channel_b = InboundV1Channel::<&TestKeysInterface>::new(
1181211851
&fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
@@ -11857,7 +11896,7 @@ mod tests {
1185711896
&logger
1185811897
).unwrap();
1185911898

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();
1186111900
let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
1186211901
let node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(
1186311902
&feeest,

0 commit comments

Comments
 (0)