Skip to content

Commit 5abe515

Browse files
arik-soarik-so
committed
Create ChannelSignerType enum.
1 parent a5b5c4d commit 5abe515

File tree

3 files changed

+86
-33
lines changed

3 files changed

+86
-33
lines changed

‎lightning/src/ln/channel.rs

Lines changed: 34 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,7 @@ use core::ops::Deref;
5151
#[cfg(any(test, fuzzing, debug_assertions))]
5252
use crate::sync::Mutex;
5353
use bitcoin::hashes::hex::ToHex;
54+
use crate::sign::type_resolver::ChannelSignerType;
5455

5556
#[cfg(test)]
5657
pub struct ChannelValueStat {
@@ -534,7 +535,7 @@ pub(super) struct Channel<Signer: ChannelSigner> {
534535

535536
latest_monitor_update_id: u64,
536537

537-
holder_signer: Signer,
538+
holder_signer: ChannelSignerType<Signer>,
538539
shutdown_scriptpubkey: Option<ShutdownScript>,
539540
destination_script: Script,
540541

@@ -1042,7 +1043,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
10421043

10431044
latest_monitor_update_id: 0,
10441045

1045-
holder_signer,
1046+
holder_signer: ChannelSignerType::Ecdsa(holder_signer),
10461047
shutdown_scriptpubkey,
10471048
destination_script,
10481049

@@ -1397,7 +1398,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
13971398

13981399
latest_monitor_update_id: 0,
13991400

1400-
holder_signer,
1401+
holder_signer: ChannelSignerType::Ecdsa(holder_signer),
14011402
shutdown_scriptpubkey,
14021403
destination_script,
14031404

@@ -1836,7 +1837,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
18361837
/// The result is a transaction which we can revoke broadcastership of (ie a "local" transaction)
18371838
/// TODO Some magic rust shit to compile-time check this?
18381839
fn build_holder_transaction_keys(&self, commitment_number: u64) -> TxCreationKeys {
1839-
let per_commitment_point = self.holder_signer.get_per_commitment_point(commitment_number, &self.secp_ctx);
1840+
let per_commitment_point = self.holder_signer.as_ref().get_per_commitment_point(commitment_number, &self.secp_ctx);
18401841
let delayed_payment_base = &self.get_holder_pubkeys().delayed_payment_basepoint;
18411842
let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
18421843
let counterparty_pubkeys = self.get_counterparty_pubkeys();
@@ -2323,7 +2324,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
23232324
log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
23242325
log_bytes!(self.channel_id()), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
23252326

2326-
let counterparty_signature = self.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
2327+
let counterparty_signature = self.holder_signer.as_ecdsa().sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
23272328
.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0;
23282329

23292330
// We sign "counterparty" commitment transaction, allowing them to broadcast the tx if they wish.
@@ -2363,7 +2364,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
23632364
self.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
23642365
// This is an externally observable change before we finish all our checks. In particular
23652366
// funding_created_signature may fail.
2366-
self.holder_signer.provide_channel_parameters(&self.channel_transaction_parameters);
2367+
self.holder_signer.as_mut().provide_channel_parameters(&self.channel_transaction_parameters);
23672368

23682369
let (counterparty_initial_commitment_txid, initial_commitment_tx, signature) = match self.funding_created_signature(&msg.signature, logger) {
23692370
Ok(res) => res,
@@ -2386,7 +2387,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
23862387
self.counterparty_funding_pubkey()
23872388
);
23882389

2389-
self.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
2390+
self.holder_signer.as_ref().validate_holder_commitment(&holder_commitment_tx, Vec::new())
23902391
.map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
23912392

23922393
// Now that we're past error-generating stuff, update our local state:
@@ -2476,7 +2477,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
24762477
self.counterparty_funding_pubkey()
24772478
);
24782479

2479-
self.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
2480+
self.holder_signer.as_ref().validate_holder_commitment(&holder_commitment_tx, Vec::new())
24802481
.map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
24812482

24822483

@@ -3245,7 +3246,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
32453246
self.counterparty_funding_pubkey()
32463247
);
32473248

3248-
self.holder_signer.validate_holder_commitment(&holder_commitment_tx, commitment_stats.preimages)
3249+
self.holder_signer.as_ref().validate_holder_commitment(&holder_commitment_tx, commitment_stats.preimages)
32493250
.map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
32503251

32513252
// Update state now that we've passed all the can-fail calls...
@@ -3505,7 +3506,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
35053506
*self.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
35063507
}
35073508

3508-
self.holder_signer.validate_counterparty_revocation(
3509+
self.holder_signer.as_ecdsa().validate_counterparty_revocation(
35093510
self.cur_counterparty_commitment_transaction_number + 1,
35103511
&secret
35113512
).map_err(|_| ChannelError::Close("Failed to validate revocation from peer".to_owned()))?;
@@ -3913,7 +3914,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
39133914
assert!(!self.is_outbound() || self.minimum_depth == Some(0),
39143915
"Funding transaction broadcast by the local client before it should have - LDK didn't do it!");
39153916
self.monitor_pending_channel_ready = false;
3916-
let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
3917+
let next_per_commitment_point = self.holder_signer.as_ref().get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
39173918
Some(msgs::ChannelReady {
39183919
channel_id: self.channel_id(),
39193920
next_per_commitment_point,
@@ -3993,8 +3994,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
39933994
}
39943995

39953996
fn get_last_revoke_and_ack(&self) -> msgs::RevokeAndACK {
3996-
let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
3997-
let per_commitment_secret = self.holder_signer.release_commitment_secret(self.cur_holder_commitment_transaction_number + 2);
3997+
let next_per_commitment_point = self.holder_signer.as_ref().get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
3998+
let per_commitment_secret = self.holder_signer.as_ref().release_commitment_secret(self.cur_holder_commitment_transaction_number + 2);
39983999
msgs::RevokeAndACK {
39994000
channel_id: self.channel_id,
40004001
per_commitment_secret,
@@ -4096,7 +4097,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
40964097
}
40974098

40984099
if msg.next_remote_commitment_number > 0 {
4099-
let expected_point = self.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1, &self.secp_ctx);
4100+
let expected_point = self.holder_signer.as_ref().get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1, &self.secp_ctx);
41004101
let given_secret = SecretKey::from_slice(&msg.your_last_per_commitment_secret)
41014102
.map_err(|_| ChannelError::Close("Peer sent a garbage channel_reestablish with unparseable secret key".to_owned()))?;
41024103
if expected_point != PublicKey::from_secret_key(&self.secp_ctx, &given_secret) {
@@ -4160,7 +4161,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
41604161
}
41614162

41624163
// We have OurChannelReady set!
4163-
let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
4164+
let next_per_commitment_point = self.holder_signer.as_ref().get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
41644165
return Ok(ReestablishResponses {
41654166
channel_ready: Some(msgs::ChannelReady {
41664167
channel_id: self.channel_id(),
@@ -4196,7 +4197,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
41964197

41974198
let channel_ready = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number == 1 {
41984199
// We should never have to worry about MonitorUpdateInProgress resending ChannelReady
4199-
let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
4200+
let next_per_commitment_point = self.holder_signer.as_ref().get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
42004201
Some(msgs::ChannelReady {
42014202
channel_id: self.channel_id(),
42024203
next_per_commitment_point,
@@ -4345,7 +4346,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
43454346
log_trace!(logger, "Proposing initial closing_signed for our counterparty with a fee range of {}-{} sat (with initial proposal {} sats)",
43464347
our_min_fee, our_max_fee, total_fee_satoshis);
43474348

4348-
let sig = self.holder_signer
4349+
let sig = self.holder_signer.as_ecdsa()
43494350
.sign_closing_transaction(&closing_tx, &self.secp_ctx)
43504351
.map_err(|()| ChannelError::Close("Failed to get signature for closing transaction.".to_owned()))?;
43514352

@@ -4555,7 +4556,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
45554556
self.build_closing_transaction($new_fee, false)
45564557
};
45574558

4558-
let sig = self.holder_signer
4559+
let sig = self.holder_signer.as_ecdsa()
45594560
.sign_closing_transaction(&closing_tx, &self.secp_ctx)
45604561
.map_err(|_| ChannelError::Close("External signer refused to sign closing transaction".to_owned()))?;
45614562

@@ -4927,7 +4928,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
49274928

49284929
#[cfg(test)]
49294930
pub fn get_signer(&self) -> &Signer {
4930-
&self.holder_signer
4931+
// the Signer parameterization will only ever be used for the ECDSA signer
4932+
self.holder_signer.as_ecdsa()
49314933
}
49324934

49334935
#[cfg(test)]
@@ -5170,7 +5172,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
51705172
if self.channel_state & (ChannelState::MonitorUpdateInProgress as u32) == 0 {
51715173
if self.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
51725174
let next_per_commitment_point =
5173-
self.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.secp_ctx);
5175+
self.holder_signer.as_ref().get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.secp_ctx);
51745176
return Some(msgs::ChannelReady {
51755177
channel_id: self.channel_id,
51765178
next_per_commitment_point,
@@ -5394,7 +5396,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
53945396
panic!("Tried to send an open_channel for a channel that has already advanced");
53955397
}
53965398

5397-
let first_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
5399+
let first_per_commitment_point = self.holder_signer.as_ref().get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
53985400
let keys = self.get_holder_pubkeys();
53995401

54005402
msgs::OpenChannel {
@@ -5464,7 +5466,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
54645466
///
54655467
/// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
54665468
fn generate_accept_channel_message(&self) -> msgs::AcceptChannel {
5467-
let first_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
5469+
let first_per_commitment_point = self.holder_signer.as_ref().get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
54685470
let keys = self.get_holder_pubkeys();
54695471

54705472
msgs::AcceptChannel {
@@ -5505,7 +5507,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
55055507
fn get_outbound_funding_created_signature<L: Deref>(&mut self, logger: &L) -> Result<Signature, ChannelError> where L::Target: Logger {
55065508
let counterparty_keys = self.build_remote_transaction_keys();
55075509
let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
5508-
Ok(self.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
5510+
Ok(self.holder_signer.as_ecdsa().sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
55095511
.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0)
55105512
}
55115513

@@ -5530,7 +5532,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
55305532
}
55315533

55325534
self.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
5533-
self.holder_signer.provide_channel_parameters(&self.channel_transaction_parameters);
5535+
self.holder_signer.as_mut().provide_channel_parameters(&self.channel_transaction_parameters);
55345536

55355537
let signature = match self.get_outbound_funding_created_signature(logger) {
55365538
Ok(res) => res,
@@ -5639,7 +5641,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
56395641
},
56405642
Ok(v) => v
56415643
};
5642-
let our_bitcoin_sig = match self.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx) {
5644+
let our_bitcoin_sig = match self.holder_signer.as_ecdsa().sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx) {
56435645
Err(_) => {
56445646
log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
56455647
return None;
@@ -5668,7 +5670,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
56685670

56695671
let our_node_sig = node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement))
56705672
.map_err(|_| ChannelError::Ignore("Failed to generate node signature for channel_announcement".to_owned()))?;
5671-
let our_bitcoin_sig = self.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx)
5673+
let our_bitcoin_sig = self.holder_signer.as_ecdsa().sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx)
56725674
.map_err(|_| ChannelError::Ignore("Signer rejected channel_announcement".to_owned()))?;
56735675
Ok(msgs::ChannelAnnouncement {
56745676
node_signature_1: if were_node_one { our_node_sig } else { their_node_sig },
@@ -6048,7 +6050,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
60486050
htlcs.push(htlc);
60496051
}
60506052

6051-
let res = self.holder_signer.sign_counterparty_commitment(&commitment_stats.tx, commitment_stats.preimages, &self.secp_ctx)
6053+
let res = self.holder_signer.as_ecdsa().sign_counterparty_commitment(&commitment_stats.tx, commitment_stats.preimages, &self.secp_ctx)
60526054
.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?;
60536055
signature = res.0;
60546056
htlc_signatures = res.1;
@@ -6360,7 +6362,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
63606362
self.latest_monitor_update_id.write(writer)?;
63616363

63626364
let mut key_data = VecWriter(Vec::new());
6363-
self.holder_signer.write(&mut key_data)?;
6365+
self.holder_signer.as_ecdsa().write(&mut key_data)?;
63646366
assert!(key_data.0.len() < core::usize::MAX);
63656367
assert!(key_data.0.len() < core::u32::MAX as usize);
63666368
(key_data.0.len() as u32).write(writer)?;
@@ -7005,7 +7007,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
70057007

70067008
latest_monitor_update_id,
70077009

7008-
holder_signer,
7010+
holder_signer: ChannelSignerType::Ecdsa(holder_signer),
70097011
shutdown_scriptpubkey,
70107012
destination_script,
70117013

@@ -7688,10 +7690,10 @@ mod tests {
76887690
// We can't just use build_holder_transaction_keys here as the per_commitment_secret is not
76897691
// derived from a commitment_seed, so instead we copy it here and call
76907692
// build_commitment_transaction.
7691-
let delayed_payment_base = &chan.holder_signer.pubkeys().delayed_payment_basepoint;
7693+
let delayed_payment_base = &chan.holder_signer.as_ref().pubkeys().delayed_payment_basepoint;
76927694
let per_commitment_secret = SecretKey::from_slice(&hex::decode("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
76937695
let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
7694-
let htlc_basepoint = &chan.holder_signer.pubkeys().htlc_basepoint;
7696+
let htlc_basepoint = &chan.holder_signer.as_ref().pubkeys().htlc_basepoint;
76957697
let keys = TxCreationKeys::derive_new(&secp_ctx, &per_commitment_point, delayed_payment_base, htlc_basepoint, &counterparty_pubkeys.revocation_basepoint, &counterparty_pubkeys.htlc_basepoint);
76967698

76977699
macro_rules! test_commitment {
@@ -7743,7 +7745,7 @@ mod tests {
77437745
commitment_tx.clone(),
77447746
counterparty_signature,
77457747
counterparty_htlc_sigs,
7746-
&chan.holder_signer.pubkeys().funding_pubkey,
7748+
chan.holder_signer.as_ref().pubkeys().funding_pubkey,
77477749
chan.counterparty_funding_pubkey()
77487750
);
77497751
let (holder_sig, htlc_sigs) = signer.sign_holder_commitment_and_htlcs(&holder_commitment_tx, &secp_ctx).unwrap();

‎lightning/src/sign/mod.rs

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,10 +49,13 @@ use core::ops::Deref;
4949
use core::sync::atomic::{AtomicUsize, Ordering};
5050
use crate::io::{self, Error};
5151
use crate::ln::msgs::{DecodeError, MAX_VALUE_MSAT};
52+
use crate::sign::type_resolver::AsChannelSigner;
5253
use crate::util::atomic_counter::AtomicCounter;
5354
use crate::util::chacha20::ChaCha20;
5455
use crate::util::invoice::construct_invoice_preimage;
5556

57+
pub(crate) mod type_resolver;
58+
5659
/// Used as initial key material, to be expanded into multiple secret keys (but not to be used
5760
/// directly). This is used within LDK to encrypt/decrypt inbound payment data.
5861
///
@@ -220,7 +223,7 @@ impl_writeable_tlv_based_enum!(SpendableOutputDescriptor,
220223

221224
/// A trait to handle Lightning channel key material without concretizing the channel type or
222225
/// the signature mechanism.
223-
pub trait ChannelSigner {
226+
pub trait ChannelSigner: AsChannelSigner {
224227
/// Gets the per-commitment point for a specific commitment number
225228
///
226229
/// Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.

‎lightning/src/sign/type_resolver.rs

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
use crate::sign::{ChannelSigner, EcdsaChannelSigner};
2+
3+
pub(crate) enum ChannelSignerType<ECS: ChannelSigner> {
4+
// in practice, this will only ever be an EcdsaChannelSigner
5+
Ecdsa(ECS)
6+
}
7+
8+
impl<ECS: EcdsaChannelSigner> ChannelSignerType<ECS> {
9+
pub(crate) fn as_ref(&self) -> &dyn ChannelSigner {
10+
match self {
11+
ChannelSignerType::Ecdsa(cs) => cs.as_channel_signer()
12+
}
13+
}
14+
15+
pub(crate) fn as_mut(&mut self) -> &mut dyn ChannelSigner {
16+
match self {
17+
ChannelSignerType::Ecdsa(cs) => cs.as_mut_channel_signer()
18+
}
19+
}
20+
21+
pub(crate) fn as_ecdsa(&self) -> &ECS {
22+
match self {
23+
ChannelSignerType::Ecdsa(ecs) => ecs
24+
}
25+
}
26+
27+
pub(crate) fn as_mut_ecdsa(&mut self) -> &mut ECS {
28+
match self {
29+
ChannelSignerType::Ecdsa(ecs) => ecs
30+
}
31+
}
32+
}
33+
34+
/// Helper trait for accessing common channel signer methods between different implementations
35+
pub trait AsChannelSigner {
36+
fn as_channel_signer(&self) -> &dyn ChannelSigner;
37+
fn as_mut_channel_signer(&mut self) -> &mut dyn ChannelSigner;
38+
}
39+
40+
impl<CS: ChannelSigner> AsChannelSigner for CS {
41+
fn as_channel_signer(&self) -> &dyn ChannelSigner {
42+
self
43+
}
44+
45+
fn as_mut_channel_signer(&mut self) -> &mut dyn ChannelSigner {
46+
self
47+
}
48+
}

0 commit comments

Comments
 (0)