X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fchan_utils.rs;h=6e0e50858f8972ff90865eb3c23f5c2ce39f10fa;hb=e7d3781dd7b8814964d063edd3c3ea230f56da21;hp=b698558e1b26b5a6c7a18cd142f4c8bce6e341b5;hpb=3996eaab6e2eaf5fde9374b51d952c0edef5ea92;p=rust-lightning diff --git a/lightning/src/ln/chan_utils.rs b/lightning/src/ln/chan_utils.rs index b698558e..6e0e5085 100644 --- a/lightning/src/ln/chan_utils.rs +++ b/lightning/src/ln/chan_utils.rs @@ -172,7 +172,7 @@ impl Writeable for CounterpartyCommitmentSecrets { writer.write_all(secret)?; writer.write_all(&byte_utils::be64_to_array(*idx))?; } - write_tlv_fields!(writer, {}, {}); + write_tlv_fields!(writer, {}); Ok(()) } } @@ -183,7 +183,7 @@ impl Readable for CounterpartyCommitmentSecrets { *secret = Readable::read(reader)?; *idx = Readable::read(reader)?; } - read_tlv_fields!(reader, {}, {}); + read_tlv_fields!(reader, {}); Ok(Self { old_secrets }) } } @@ -318,12 +318,12 @@ pub struct TxCreationKeys { } impl_writeable_tlv_based!(TxCreationKeys, { - (0, per_commitment_point), - (2, revocation_key), - (4, broadcaster_htlc_key), - (6, countersignatory_htlc_key), - (8, broadcaster_delayed_payment_key), -}, {}, {}); + (0, per_commitment_point, required), + (2, revocation_key, required), + (4, broadcaster_htlc_key, required), + (6, countersignatory_htlc_key, required), + (8, broadcaster_delayed_payment_key, required), +}); /// One counterparty's public keys which do not change over the life of a channel. #[derive(Clone, PartialEq)] @@ -350,12 +350,12 @@ pub struct ChannelPublicKeys { } impl_writeable_tlv_based!(ChannelPublicKeys, { - (0, funding_pubkey), - (2, revocation_basepoint), - (4, payment_point), - (6, delayed_payment_basepoint), - (8, htlc_basepoint), -}, {}, {}); + (0, funding_pubkey, required), + (2, revocation_basepoint, required), + (4, payment_point, required), + (6, delayed_payment_basepoint, required), + (8, htlc_basepoint, required), +}); impl TxCreationKeys { /// Create per-state keys from channel base points and the per-commitment point. @@ -429,13 +429,12 @@ pub struct HTLCOutputInCommitment { } impl_writeable_tlv_based!(HTLCOutputInCommitment, { - (0, offered), - (2, amount_msat), - (4, cltv_expiry), - (6, payment_hash), -}, { - (8, transaction_output_index) -}, {}); + (0, offered, required), + (2, amount_msat, required), + (4, cltv_expiry, required), + (6, payment_hash, required), + (8, transaction_output_index, option), +}); #[inline] pub(crate) fn get_htlc_redeemscript_with_explicit_keys(htlc: &HTLCOutputInCommitment, broadcaster_htlc_key: &PublicKey, countersignatory_htlc_key: &PublicKey, revocation_key: &PublicKey) -> Script { @@ -525,12 +524,18 @@ pub fn make_funding_redeemscript(broadcaster: &PublicKey, countersignatory: &Pub }.push_opcode(opcodes::all::OP_PUSHNUM_2).push_opcode(opcodes::all::OP_CHECKMULTISIG).into_script() } -/// panics if htlc.transaction_output_index.is_none()! -pub fn build_htlc_transaction(prev_hash: &Txid, feerate_per_kw: u32, contest_delay: u16, htlc: &HTLCOutputInCommitment, broadcaster_delayed_payment_key: &PublicKey, revocation_key: &PublicKey) -> Transaction { +/// Builds an unsigned HTLC-Success or HTLC-Timeout transaction from the given channel and HTLC +/// parameters. This is used by [`TrustedCommitmentTransaction::get_htlc_sigs`] to fetch the +/// transaction which needs signing, and can be used to construct an HTLC transaction which is +/// broadcastable given a counterparty HTLC signature. +/// +/// Panics if htlc.transaction_output_index.is_none() (as such HTLCs do not appear in the +/// commitment transaction). +pub fn build_htlc_transaction(commitment_txid: &Txid, feerate_per_kw: u32, contest_delay: u16, htlc: &HTLCOutputInCommitment, broadcaster_delayed_payment_key: &PublicKey, revocation_key: &PublicKey) -> Transaction { let mut txins: Vec = Vec::new(); txins.push(TxIn { previous_output: OutPoint { - txid: prev_hash.clone(), + txid: commitment_txid.clone(), vout: htlc.transaction_output_index.expect("Can't build an HTLC transaction for a dust output"), }, script_sig: Script::new(), @@ -620,18 +625,17 @@ impl ChannelTransactionParameters { } impl_writeable_tlv_based!(CounterpartyChannelTransactionParameters, { - (0, pubkeys), - (2, selected_contest_delay), -}, {}, {}); + (0, pubkeys, required), + (2, selected_contest_delay, required), +}); impl_writeable_tlv_based!(ChannelTransactionParameters, { - (0, holder_pubkeys), - (2, holder_selected_contest_delay), - (4, is_outbound_from_holder), -}, { - (6, counterparty_parameters), - (8, funding_outpoint), -}, {}); + (0, holder_pubkeys, required), + (2, holder_selected_contest_delay, required), + (4, is_outbound_from_holder, required), + (6, counterparty_parameters, option), + (8, funding_outpoint, option), +}); /// Static channel fields used to build transactions given per-commitment fields, organized by /// broadcaster/countersignatory. @@ -714,11 +718,10 @@ impl PartialEq for HolderCommitmentTransaction { } impl_writeable_tlv_based!(HolderCommitmentTransaction, { - (0, inner), - (2, counterparty_sig), - (4, holder_sig_first), -}, {}, { - (6, counterparty_htlc_sigs), + (0, inner, required), + (2, counterparty_sig, required), + (4, holder_sig_first, required), + (6, counterparty_htlc_sigs, vec_type), }); impl HolderCommitmentTransaction { @@ -803,9 +806,9 @@ pub struct BuiltCommitmentTransaction { } impl_writeable_tlv_based!(BuiltCommitmentTransaction, { - (0, transaction), - (2, txid) -}, {}, {}); + (0, transaction, required), + (2, txid, required), +}); impl BuiltCommitmentTransaction { /// Get the SIGHASH_ALL sighash value of the transaction. @@ -860,14 +863,13 @@ impl PartialEq for CommitmentTransaction { } impl_writeable_tlv_based!(CommitmentTransaction, { - (0, commitment_number), - (2, to_broadcaster_value_sat), - (4, to_countersignatory_value_sat), - (6, feerate_per_kw), - (8, keys), - (10, built), -}, {}, { - (12, htlcs), + (0, commitment_number, required), + (2, to_broadcaster_value_sat, required), + (4, to_countersignatory_value_sat, required), + (6, feerate_per_kw, required), + (8, keys, required), + (10, built, required), + (12, htlcs, vec_type), }); impl CommitmentTransaction { @@ -1177,7 +1179,12 @@ impl<'a> TrustedCommitmentTransaction<'a> { } } -/// Get the transaction number obscure factor +/// Commitment transaction numbers which appear in the transactions themselves are XOR'd with a +/// shared secret first. This prevents on-chain observers from discovering how many commitment +/// transactions occurred in a channel before it was closed. +/// +/// This function gets the shared secret from relevant channel public keys and can be used to +/// "decrypt" the commitment transaction number given a commitment transaction on-chain. pub fn get_commitment_transaction_number_obscure_factor( broadcaster_payment_basepoint: &PublicKey, countersignatory_payment_basepoint: &PublicKey,