|
| 1 | +//! Defines ECDSA-specific signer types. |
| 2 | +
|
| 3 | +use bitcoin::blockdata::transaction::Transaction; |
| 4 | + |
| 5 | +use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; |
| 6 | +use bitcoin::secp256k1::ecdsa::Signature; |
| 7 | +use bitcoin::secp256k1; |
| 8 | + |
| 9 | +use crate::util::ser::Writeable; |
| 10 | +use crate::events::bump_transaction::HTLCDescriptor; |
| 11 | +use crate::ln::PaymentPreimage; |
| 12 | +use crate::ln::chan_utils::{HTLCOutputInCommitment, HolderCommitmentTransaction, CommitmentTransaction, ClosingTransaction}; |
| 13 | +use crate::ln::msgs::UnsignedChannelAnnouncement; |
| 14 | + |
| 15 | +use crate::prelude::*; |
| 16 | +use crate::sign::ChannelSigner; |
| 17 | + |
| 18 | +/// A trait to sign Lightning channel transactions as described in |
| 19 | +/// [BOLT 3](https://github.com/lightning/bolts/blob/master/03-transactions.md). |
| 20 | +/// |
| 21 | +/// Signing services could be implemented on a hardware wallet and should implement signing |
| 22 | +/// policies in order to be secure. Please refer to the [VLS Policy |
| 23 | +/// Controls](https://gitlab.com/lightning-signer/validating-lightning-signer/-/blob/main/docs/policy-controls.md) |
| 24 | +/// for an example of such policies. |
| 25 | +pub trait EcdsaChannelSigner: ChannelSigner { |
| 26 | + /// Create a signature for a counterparty's commitment transaction and associated HTLC transactions. |
| 27 | + /// |
| 28 | + /// Note that if signing fails or is rejected, the channel will be force-closed. |
| 29 | + /// |
| 30 | + /// Policy checks should be implemented in this function, including checking the amount |
| 31 | + /// sent to us and checking the HTLCs. |
| 32 | + /// |
| 33 | + /// The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided. |
| 34 | + /// A validating signer should ensure that an HTLC output is removed only when the matching |
| 35 | + /// preimage is provided, or when the value to holder is restored. |
| 36 | + /// |
| 37 | + /// Note that all the relevant preimages will be provided, but there may also be additional |
| 38 | + /// irrelevant or duplicate preimages. |
| 39 | + // |
| 40 | + // TODO: Document the things someone using this interface should enforce before signing. |
| 41 | + fn sign_counterparty_commitment(&self, commitment_tx: &CommitmentTransaction, |
| 42 | + preimages: Vec<PaymentPreimage>, secp_ctx: &Secp256k1<secp256k1::All> |
| 43 | + ) -> Result<(Signature, Vec<Signature>), ()>; |
| 44 | + /// Validate the counterparty's revocation. |
| 45 | + /// |
| 46 | + /// This is required in order for the signer to make sure that the state has moved |
| 47 | + /// forward and it is safe to sign the next counterparty commitment. |
| 48 | + fn validate_counterparty_revocation(&self, idx: u64, secret: &SecretKey) -> Result<(), ()>; |
| 49 | + /// Creates a signature for a holder's commitment transaction and its claiming HTLC transactions. |
| 50 | + /// |
| 51 | + /// This will be called |
| 52 | + /// - with a non-revoked `commitment_tx`. |
| 53 | + /// - with the latest `commitment_tx` when we initiate a force-close. |
| 54 | + /// - with the previous `commitment_tx`, just to get claiming HTLC |
| 55 | + /// signatures, if we are reacting to a [`ChannelMonitor`] |
| 56 | + /// [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas) |
| 57 | + /// that decided to broadcast before it had been updated to the latest `commitment_tx`. |
| 58 | + /// |
| 59 | + /// This may be called multiple times for the same transaction. |
| 60 | + /// |
| 61 | + /// An external signer implementation should check that the commitment has not been revoked. |
| 62 | + /// |
| 63 | + /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor |
| 64 | + // TODO: Document the things someone using this interface should enforce before signing. |
| 65 | + fn sign_holder_commitment_and_htlcs(&self, commitment_tx: &HolderCommitmentTransaction, |
| 66 | + secp_ctx: &Secp256k1<secp256k1::All>) -> Result<(Signature, Vec<Signature>), ()>; |
| 67 | + /// Same as [`sign_holder_commitment_and_htlcs`], but exists only for tests to get access to |
| 68 | + /// holder commitment transactions which will be broadcasted later, after the channel has moved |
| 69 | + /// on to a newer state. Thus, needs its own method as [`sign_holder_commitment_and_htlcs`] may |
| 70 | + /// enforce that we only ever get called once. |
| 71 | + #[cfg(any(test,feature = "unsafe_revoked_tx_signing"))] |
| 72 | + fn unsafe_sign_holder_commitment_and_htlcs(&self, commitment_tx: &HolderCommitmentTransaction, |
| 73 | + secp_ctx: &Secp256k1<secp256k1::All>) -> Result<(Signature, Vec<Signature>), ()>; |
| 74 | + /// Create a signature for the given input in a transaction spending an HTLC transaction output |
| 75 | + /// or a commitment transaction `to_local` output when our counterparty broadcasts an old state. |
| 76 | + /// |
| 77 | + /// A justice transaction may claim multiple outputs at the same time if timelocks are |
| 78 | + /// similar, but only a signature for the input at index `input` should be signed for here. |
| 79 | + /// It may be called multiple times for same output(s) if a fee-bump is needed with regards |
| 80 | + /// to an upcoming timelock expiration. |
| 81 | + /// |
| 82 | + /// Amount is value of the output spent by this input, committed to in the BIP 143 signature. |
| 83 | + /// |
| 84 | + /// `per_commitment_key` is revocation secret which was provided by our counterparty when they |
| 85 | + /// revoked the state which they eventually broadcast. It's not a _holder_ secret key and does |
| 86 | + /// not allow the spending of any funds by itself (you need our holder `revocation_secret` to do |
| 87 | + /// so). |
| 88 | + fn sign_justice_revoked_output(&self, justice_tx: &Transaction, input: usize, amount: u64, |
| 89 | + per_commitment_key: &SecretKey, secp_ctx: &Secp256k1<secp256k1::All> |
| 90 | + ) -> Result<Signature, ()>; |
| 91 | + /// Create a signature for the given input in a transaction spending a commitment transaction |
| 92 | + /// HTLC output when our counterparty broadcasts an old state. |
| 93 | + /// |
| 94 | + /// A justice transaction may claim multiple outputs at the same time if timelocks are |
| 95 | + /// similar, but only a signature for the input at index `input` should be signed for here. |
| 96 | + /// It may be called multiple times for same output(s) if a fee-bump is needed with regards |
| 97 | + /// to an upcoming timelock expiration. |
| 98 | + /// |
| 99 | + /// `amount` is the value of the output spent by this input, committed to in the BIP 143 |
| 100 | + /// signature. |
| 101 | + /// |
| 102 | + /// `per_commitment_key` is revocation secret which was provided by our counterparty when they |
| 103 | + /// revoked the state which they eventually broadcast. It's not a _holder_ secret key and does |
| 104 | + /// not allow the spending of any funds by itself (you need our holder revocation_secret to do |
| 105 | + /// so). |
| 106 | + /// |
| 107 | + /// `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script |
| 108 | + /// (which is committed to in the BIP 143 signatures). |
| 109 | + fn sign_justice_revoked_htlc(&self, justice_tx: &Transaction, input: usize, amount: u64, |
| 110 | + per_commitment_key: &SecretKey, htlc: &HTLCOutputInCommitment, |
| 111 | + secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()>; |
| 112 | + /// Computes the signature for a commitment transaction's HTLC output used as an input within |
| 113 | + /// `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned |
| 114 | + /// must be be computed using [`EcdsaSighashType::All`]. Note that this should only be used to |
| 115 | + /// sign HTLC transactions from channels supporting anchor outputs after all additional |
| 116 | + /// inputs/outputs have been added to the transaction. |
| 117 | + /// |
| 118 | + /// [`EcdsaSighashType::All`]: bitcoin::blockdata::transaction::EcdsaSighashType::All |
| 119 | + fn sign_holder_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, |
| 120 | + htlc_descriptor: &HTLCDescriptor, secp_ctx: &Secp256k1<secp256k1::All> |
| 121 | + ) -> Result<Signature, ()>; |
| 122 | + /// Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment |
| 123 | + /// transaction, either offered or received. |
| 124 | + /// |
| 125 | + /// Such a transaction may claim multiples offered outputs at same time if we know the |
| 126 | + /// preimage for each when we create it, but only the input at index `input` should be |
| 127 | + /// signed for here. It may be called multiple times for same output(s) if a fee-bump is |
| 128 | + /// needed with regards to an upcoming timelock expiration. |
| 129 | + /// |
| 130 | + /// `witness_script` is either an offered or received script as defined in BOLT3 for HTLC |
| 131 | + /// outputs. |
| 132 | + /// |
| 133 | + /// `amount` is value of the output spent by this input, committed to in the BIP 143 signature. |
| 134 | + /// |
| 135 | + /// `per_commitment_point` is the dynamic point corresponding to the channel state |
| 136 | + /// detected onchain. It has been generated by our counterparty and is used to derive |
| 137 | + /// channel state keys, which are then included in the witness script and committed to in the |
| 138 | + /// BIP 143 signature. |
| 139 | + fn sign_counterparty_htlc_transaction(&self, htlc_tx: &Transaction, input: usize, amount: u64, |
| 140 | + per_commitment_point: &PublicKey, htlc: &HTLCOutputInCommitment, |
| 141 | + secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()>; |
| 142 | + /// Create a signature for a (proposed) closing transaction. |
| 143 | + /// |
| 144 | + /// Note that, due to rounding, there may be one "missing" satoshi, and either party may have |
| 145 | + /// chosen to forgo their output as dust. |
| 146 | + fn sign_closing_transaction(&self, closing_tx: &ClosingTransaction, |
| 147 | + secp_ctx: &Secp256k1<secp256k1::All>) -> Result<Signature, ()>; |
| 148 | + /// Computes the signature for a commitment transaction's anchor output used as an |
| 149 | + /// input within `anchor_tx`, which spends the commitment transaction, at index `input`. |
| 150 | + fn sign_holder_anchor_input( |
| 151 | + &self, anchor_tx: &Transaction, input: usize, secp_ctx: &Secp256k1<secp256k1::All>, |
| 152 | + ) -> Result<Signature, ()>; |
| 153 | + /// Signs a channel announcement message with our funding key proving it comes from one of the |
| 154 | + /// channel participants. |
| 155 | + /// |
| 156 | + /// Channel announcements also require a signature from each node's network key. Our node |
| 157 | + /// signature is computed through [`NodeSigner::sign_gossip_message`]. |
| 158 | + /// |
| 159 | + /// Note that if this fails or is rejected, the channel will not be publicly announced and |
| 160 | + /// our counterparty may (though likely will not) close the channel on us for violating the |
| 161 | + /// protocol. |
| 162 | + /// |
| 163 | + /// [`NodeSigner::sign_gossip_message`]: crate::sign::NodeSigner::sign_gossip_message |
| 164 | + fn sign_channel_announcement_with_funding_key( |
| 165 | + &self, msg: &UnsignedChannelAnnouncement, secp_ctx: &Secp256k1<secp256k1::All> |
| 166 | + ) -> Result<Signature, ()>; |
| 167 | +} |
| 168 | + |
| 169 | +/// A writeable signer. |
| 170 | +/// |
| 171 | +/// There will always be two instances of a signer per channel, one occupied by the |
| 172 | +/// [`ChannelManager`] and another by the channel's [`ChannelMonitor`]. |
| 173 | +/// |
| 174 | +/// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager |
| 175 | +/// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor |
| 176 | +pub trait WriteableEcdsaChannelSigner: EcdsaChannelSigner + Writeable {} |
0 commit comments