1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Wire messages, traits representing wire message handlers, and a few error types live here.
12 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
13 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
14 //! server entirely) which handles only channel-related messages you may wish to implement
15 //! [`ChannelMessageHandler`] yourself and use it to re-serialize messages and pass them across
18 //! Note that if you go with such an architecture (instead of passing raw socket events to a
19 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
20 //! source `node_id` of the message, however this does allow you to significantly reduce bandwidth
21 //! between the systems as routing messages can represent a significant chunk of bandwidth usage
22 //! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids
23 //! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send
24 //! raw socket events into your non-internet-facing system and then send routing events back to
25 //! track the network on the less-secure system.
27 use bitcoin::secp256k1::PublicKey;
28 use bitcoin::secp256k1::ecdsa::Signature;
29 use bitcoin::{secp256k1, Witness, Transaction};
30 use bitcoin::blockdata::script::Script;
31 use bitcoin::hash_types::{Txid, BlockHash};
33 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
34 use crate::ln::onion_utils;
35 use crate::onion_message;
37 use crate::prelude::*;
40 use crate::io::{self, Read};
41 use crate::io_extras::read_to_end;
43 use crate::events::{MessageSendEventsProvider, OnionMessageProvider};
44 use crate::util::logger;
45 use crate::util::ser::{LengthReadable, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname};
47 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
49 use crate::routing::gossip::{NodeAlias, NodeId};
51 /// 21 million * 10^8 * 1000
52 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
55 /// A partial signature that also contains the Musig2 nonce its signer used
56 #[derive(Clone, Debug, PartialEq, Eq)]
57 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
59 /// An error in decoding a message or struct.
60 #[derive(Clone, Debug, PartialEq, Eq)]
61 pub enum DecodeError {
62 /// A version byte specified something we don't know how to handle.
64 /// Includes unknown realm byte in an onion hop data packet.
66 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
67 UnknownRequiredFeature,
68 /// Value was invalid.
70 /// For example, a byte which was supposed to be a bool was something other than a 0
71 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
72 /// syntactically incorrect, etc.
74 /// The buffer to be read was too short.
76 /// A length descriptor in the packet didn't describe the later data correctly.
78 /// Error from [`std::io`].
80 /// The message included zlib-compressed values, which we don't support.
81 UnsupportedCompression,
84 /// An [`init`] message to be sent to or received from a peer.
86 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
87 #[derive(Clone, Debug, PartialEq, Eq)]
89 /// The relevant features which the sender supports.
90 pub features: InitFeatures,
91 /// The receipient's network address.
93 /// This adds the option to report a remote IP address back to a connecting peer using the init
94 /// message. A node can decide to use that information to discover a potential update to its
95 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
97 pub remote_network_address: Option<NetAddress>,
100 /// An [`error`] message to be sent to or received from a peer.
102 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
103 #[derive(Clone, Debug, PartialEq, Eq)]
104 pub struct ErrorMessage {
105 /// The channel ID involved in the error.
107 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
108 /// with the sending peer should be closed.
109 pub channel_id: [u8; 32],
110 /// A possibly human-readable error description.
112 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
113 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
114 /// the terminal emulator or the logging subsystem.
118 /// A [`warning`] message to be sent to or received from a peer.
120 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
121 #[derive(Clone, Debug, PartialEq, Eq)]
122 pub struct WarningMessage {
123 /// The channel ID involved in the warning.
125 /// All-0s indicates a warning unrelated to a specific channel.
126 pub channel_id: [u8; 32],
127 /// A possibly human-readable warning description.
129 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
130 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
131 /// the terminal emulator or the logging subsystem.
135 /// A [`ping`] message to be sent to or received from a peer.
137 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
138 #[derive(Clone, Debug, PartialEq, Eq)]
140 /// The desired response length.
142 /// The ping packet size.
144 /// This field is not sent on the wire. byteslen zeros are sent.
148 /// A [`pong`] message to be sent to or received from a peer.
150 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
151 #[derive(Clone, Debug, PartialEq, Eq)]
153 /// The pong packet size.
155 /// This field is not sent on the wire. byteslen zeros are sent.
159 /// An [`open_channel`] message to be sent to or received from a peer.
161 /// Used in V1 channel establishment
163 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
164 #[derive(Clone, Debug, PartialEq, Eq)]
165 pub struct OpenChannel {
166 /// The genesis hash of the blockchain where the channel is to be opened
167 pub chain_hash: BlockHash,
168 /// A temporary channel ID, until the funding outpoint is announced
169 pub temporary_channel_id: [u8; 32],
170 /// The channel value
171 pub funding_satoshis: u64,
172 /// The amount to push to the counterparty as part of the open, in milli-satoshi
174 /// The threshold below which outputs on transactions broadcast by sender will be omitted
175 pub dust_limit_satoshis: u64,
176 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
177 pub max_htlc_value_in_flight_msat: u64,
178 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
179 pub channel_reserve_satoshis: u64,
180 /// The minimum HTLC size incoming to sender, in milli-satoshi
181 pub htlc_minimum_msat: u64,
182 /// The feerate per 1000-weight of sender generated transactions, until updated by
184 pub feerate_per_kw: u32,
185 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
186 /// they broadcast a commitment transaction
187 pub to_self_delay: u16,
188 /// The maximum number of inbound HTLCs towards sender
189 pub max_accepted_htlcs: u16,
190 /// The sender's key controlling the funding transaction
191 pub funding_pubkey: PublicKey,
192 /// Used to derive a revocation key for transactions broadcast by counterparty
193 pub revocation_basepoint: PublicKey,
194 /// A payment key to sender for transactions broadcast by counterparty
195 pub payment_point: PublicKey,
196 /// Used to derive a payment key to sender for transactions broadcast by sender
197 pub delayed_payment_basepoint: PublicKey,
198 /// Used to derive an HTLC payment key to sender
199 pub htlc_basepoint: PublicKey,
200 /// The first to-be-broadcast-by-sender transaction's per commitment point
201 pub first_per_commitment_point: PublicKey,
202 /// The channel flags to be used
203 pub channel_flags: u8,
204 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
205 pub shutdown_scriptpubkey: Option<Script>,
206 /// The channel type that this channel will represent
208 /// If this is `None`, we derive the channel type from the intersection of our
209 /// feature bits with our counterparty's feature bits from the [`Init`] message.
210 pub channel_type: Option<ChannelTypeFeatures>,
213 /// An open_channel2 message to be sent by or received from the channel initiator.
215 /// Used in V2 channel establishment
217 // TODO(dual_funding): Add spec link for `open_channel2`.
218 #[derive(Clone, Debug, PartialEq, Eq)]
219 pub struct OpenChannelV2 {
220 /// The genesis hash of the blockchain where the channel is to be opened
221 pub chain_hash: BlockHash,
222 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
223 pub temporary_channel_id: [u8; 32],
224 /// The feerate for the funding transaction set by the channel initiator
225 pub funding_feerate_sat_per_1000_weight: u32,
226 /// The feerate for the commitment transaction set by the channel initiator
227 pub commitment_feerate_sat_per_1000_weight: u32,
228 /// Part of the channel value contributed by the channel initiator
229 pub funding_satoshis: u64,
230 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
232 pub dust_limit_satoshis: u64,
233 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
234 pub max_htlc_value_in_flight_msat: u64,
235 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
236 pub htlc_minimum_msat: u64,
237 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
238 /// broadcast a commitment transaction
239 pub to_self_delay: u16,
240 /// The maximum number of inbound HTLCs towards channel initiator
241 pub max_accepted_htlcs: u16,
242 /// The locktime for the funding transaction
244 /// The channel initiator's key controlling the funding transaction
245 pub funding_pubkey: PublicKey,
246 /// Used to derive a revocation key for transactions broadcast by counterparty
247 pub revocation_basepoint: PublicKey,
248 /// A payment key to channel initiator for transactions broadcast by counterparty
249 pub payment_basepoint: PublicKey,
250 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
252 pub delayed_payment_basepoint: PublicKey,
253 /// Used to derive an HTLC payment key to channel initiator
254 pub htlc_basepoint: PublicKey,
255 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
256 pub first_per_commitment_point: PublicKey,
257 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
258 pub second_per_commitment_point: PublicKey,
260 pub channel_flags: u8,
261 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
262 /// collaboratively close
263 pub shutdown_scriptpubkey: Option<Script>,
264 /// The channel type that this channel will represent. If none is set, we derive the channel
265 /// type from the intersection of our feature bits with our counterparty's feature bits from
266 /// the Init message.
267 pub channel_type: Option<ChannelTypeFeatures>,
268 /// Optionally, a requirement that only confirmed inputs can be added
269 pub require_confirmed_inputs: Option<()>,
272 /// An [`accept_channel`] message to be sent to or received from a peer.
274 /// Used in V1 channel establishment
276 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
277 #[derive(Clone, Debug, PartialEq, Eq)]
278 pub struct AcceptChannel {
279 /// A temporary channel ID, until the funding outpoint is announced
280 pub temporary_channel_id: [u8; 32],
281 /// The threshold below which outputs on transactions broadcast by sender will be omitted
282 pub dust_limit_satoshis: u64,
283 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
284 pub max_htlc_value_in_flight_msat: u64,
285 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
286 pub channel_reserve_satoshis: u64,
287 /// The minimum HTLC size incoming to sender, in milli-satoshi
288 pub htlc_minimum_msat: u64,
289 /// Minimum depth of the funding transaction before the channel is considered open
290 pub minimum_depth: u32,
291 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
292 pub to_self_delay: u16,
293 /// The maximum number of inbound HTLCs towards sender
294 pub max_accepted_htlcs: u16,
295 /// The sender's key controlling the funding transaction
296 pub funding_pubkey: PublicKey,
297 /// Used to derive a revocation key for transactions broadcast by counterparty
298 pub revocation_basepoint: PublicKey,
299 /// A payment key to sender for transactions broadcast by counterparty
300 pub payment_point: PublicKey,
301 /// Used to derive a payment key to sender for transactions broadcast by sender
302 pub delayed_payment_basepoint: PublicKey,
303 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
304 pub htlc_basepoint: PublicKey,
305 /// The first to-be-broadcast-by-sender transaction's per commitment point
306 pub first_per_commitment_point: PublicKey,
307 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
308 pub shutdown_scriptpubkey: Option<Script>,
309 /// The channel type that this channel will represent.
311 /// If this is `None`, we derive the channel type from the intersection of
312 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
313 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
314 pub channel_type: Option<ChannelTypeFeatures>,
316 /// Next nonce the channel initiator should use to create a funding output signature against
317 pub next_local_nonce: Option<musig2::types::PublicNonce>,
320 /// An accept_channel2 message to be sent by or received from the channel accepter.
322 /// Used in V2 channel establishment
324 // TODO(dual_funding): Add spec link for `accept_channel2`.
325 #[derive(Clone, Debug, PartialEq, Eq)]
326 pub struct AcceptChannelV2 {
327 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
328 pub temporary_channel_id: [u8; 32],
329 /// Part of the channel value contributed by the channel acceptor
330 pub funding_satoshis: u64,
331 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
333 pub dust_limit_satoshis: u64,
334 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
335 pub max_htlc_value_in_flight_msat: u64,
336 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
337 pub htlc_minimum_msat: u64,
338 /// Minimum depth of the funding transaction before the channel is considered open
339 pub minimum_depth: u32,
340 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
341 /// broadcast a commitment transaction
342 pub to_self_delay: u16,
343 /// The maximum number of inbound HTLCs towards channel acceptor
344 pub max_accepted_htlcs: u16,
345 /// The channel acceptor's key controlling the funding transaction
346 pub funding_pubkey: PublicKey,
347 /// Used to derive a revocation key for transactions broadcast by counterparty
348 pub revocation_basepoint: PublicKey,
349 /// A payment key to channel acceptor for transactions broadcast by counterparty
350 pub payment_basepoint: PublicKey,
351 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
353 pub delayed_payment_basepoint: PublicKey,
354 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
355 pub htlc_basepoint: PublicKey,
356 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
357 pub first_per_commitment_point: PublicKey,
358 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
359 pub second_per_commitment_point: PublicKey,
360 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
361 /// collaboratively close
362 pub shutdown_scriptpubkey: Option<Script>,
363 /// The channel type that this channel will represent. If none is set, we derive the channel
364 /// type from the intersection of our feature bits with our counterparty's feature bits from
365 /// the Init message.
367 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
368 pub channel_type: Option<ChannelTypeFeatures>,
369 /// Optionally, a requirement that only confirmed inputs can be added
370 pub require_confirmed_inputs: Option<()>,
373 /// A [`funding_created`] message to be sent to or received from a peer.
375 /// Used in V1 channel establishment
377 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
378 #[derive(Clone, Debug, PartialEq, Eq)]
379 pub struct FundingCreated {
380 /// A temporary channel ID, until the funding is established
381 pub temporary_channel_id: [u8; 32],
382 /// The funding transaction ID
383 pub funding_txid: Txid,
384 /// The specific output index funding this channel
385 pub funding_output_index: u16,
386 /// The signature of the channel initiator (funder) on the initial commitment transaction
387 pub signature: Signature,
389 /// The partial signature of the channel initiator (funder)
390 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
392 /// Next nonce the channel acceptor should use to finalize the funding output signature
393 pub next_local_nonce: Option<musig2::types::PublicNonce>
396 /// A [`funding_signed`] message to be sent to or received from a peer.
398 /// Used in V1 channel establishment
400 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
401 #[derive(Clone, Debug, PartialEq, Eq)]
402 pub struct FundingSigned {
404 pub channel_id: [u8; 32],
405 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
406 pub signature: Signature,
408 /// The partial signature of the channel acceptor (fundee)
409 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
412 /// A [`channel_ready`] message to be sent to or received from a peer.
414 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
415 #[derive(Clone, Debug, PartialEq, Eq)]
416 pub struct ChannelReady {
418 pub channel_id: [u8; 32],
419 /// The per-commitment point of the second commitment transaction
420 pub next_per_commitment_point: PublicKey,
421 /// If set, provides a `short_channel_id` alias for this channel.
423 /// The sender will accept payments to be forwarded over this SCID and forward them to this
424 /// messages' recipient.
425 pub short_channel_id_alias: Option<u64>,
428 /// A wrapper for a `Transaction` which can only be constructed with [`TransactionU16LenLimited::new`]
429 /// if the `Transaction`'s consensus-serialized length is <= u16::MAX.
431 /// Use [`TransactionU16LenLimited::into_transaction`] to convert into the contained `Transaction`.
432 #[derive(Clone, Debug, PartialEq, Eq)]
433 pub struct TransactionU16LenLimited(Transaction);
435 impl TransactionU16LenLimited {
436 /// Constructs a new `TransactionU16LenLimited` from a `Transaction` only if it's consensus-
437 /// serialized length is <= u16::MAX.
438 pub fn new(transaction: Transaction) -> Result<Self, ()> {
439 if transaction.serialized_length() > (u16::MAX as usize) {
442 Ok(Self(transaction))
446 /// Consumes this `TransactionU16LenLimited` and returns its contained `Transaction`.
447 pub fn into_transaction(self) -> Transaction {
452 impl Writeable for TransactionU16LenLimited {
453 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
454 (self.0.serialized_length() as u16).write(w)?;
459 impl Readable for TransactionU16LenLimited {
460 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
461 let len = <u16 as Readable>::read(r)?;
462 let mut tx_reader = FixedLengthReader::new(r, len as u64);
463 Ok(Self(Readable::read(&mut tx_reader)?))
467 /// A tx_add_input message for adding an input during interactive transaction construction
469 // TODO(dual_funding): Add spec link for `tx_add_input`.
470 #[derive(Clone, Debug, PartialEq, Eq)]
471 pub struct TxAddInput {
473 pub channel_id: [u8; 32],
474 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
477 /// Serialized transaction that contains the output this input spends to verify that it is non
479 pub prevtx: TransactionU16LenLimited,
480 /// The index of the output being spent
482 /// The sequence number of this input
486 /// A tx_add_output message for adding an output during interactive transaction construction.
488 // TODO(dual_funding): Add spec link for `tx_add_output`.
489 #[derive(Clone, Debug, PartialEq, Eq)]
490 pub struct TxAddOutput {
492 pub channel_id: [u8; 32],
493 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
496 /// The satoshi value of the output
498 /// The scriptPubKey for the output
502 /// A tx_remove_input message for removing an input during interactive transaction construction.
504 // TODO(dual_funding): Add spec link for `tx_remove_input`.
505 #[derive(Clone, Debug, PartialEq, Eq)]
506 pub struct TxRemoveInput {
508 pub channel_id: [u8; 32],
509 /// The serial ID of the input to be removed
513 /// A tx_remove_output message for removing an output during interactive transaction construction.
515 // TODO(dual_funding): Add spec link for `tx_remove_output`.
516 #[derive(Clone, Debug, PartialEq, Eq)]
517 pub struct TxRemoveOutput {
519 pub channel_id: [u8; 32],
520 /// The serial ID of the output to be removed
524 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
525 /// interactive transaction construction.
527 // TODO(dual_funding): Add spec link for `tx_complete`.
528 #[derive(Clone, Debug, PartialEq, Eq)]
529 pub struct TxComplete {
531 pub channel_id: [u8; 32],
534 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
535 /// interactive transaction construction.
537 // TODO(dual_funding): Add spec link for `tx_signatures`.
538 #[derive(Clone, Debug, PartialEq, Eq)]
539 pub struct TxSignatures {
541 pub channel_id: [u8; 32],
544 /// The list of witnesses
545 pub witnesses: Vec<Witness>,
548 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
551 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
552 #[derive(Clone, Debug, PartialEq, Eq)]
553 pub struct TxInitRbf {
555 pub channel_id: [u8; 32],
556 /// The locktime of the transaction
558 /// The feerate of the transaction
559 pub feerate_sat_per_1000_weight: u32,
560 /// The number of satoshis the sender will contribute to or, if negative, remove from
561 /// (e.g. splice-out) the funding output of the transaction
562 pub funding_output_contribution: Option<i64>,
565 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
568 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
569 #[derive(Clone, Debug, PartialEq, Eq)]
570 pub struct TxAckRbf {
572 pub channel_id: [u8; 32],
573 /// The number of satoshis the sender will contribute to or, if negative, remove from
574 /// (e.g. splice-out) the funding output of the transaction
575 pub funding_output_contribution: Option<i64>,
578 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
580 // TODO(dual_funding): Add spec link for `tx_abort`.
581 #[derive(Clone, Debug, PartialEq, Eq)]
584 pub channel_id: [u8; 32],
589 /// A [`shutdown`] message to be sent to or received from a peer.
591 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
592 #[derive(Clone, Debug, PartialEq, Eq)]
593 pub struct Shutdown {
595 pub channel_id: [u8; 32],
596 /// The destination of this peer's funds on closing.
598 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
599 pub scriptpubkey: Script,
602 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
604 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
606 #[derive(Clone, Debug, PartialEq, Eq)]
607 pub struct ClosingSignedFeeRange {
608 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
610 pub min_fee_satoshis: u64,
611 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
613 pub max_fee_satoshis: u64,
616 /// A [`closing_signed`] message to be sent to or received from a peer.
618 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
619 #[derive(Clone, Debug, PartialEq, Eq)]
620 pub struct ClosingSigned {
622 pub channel_id: [u8; 32],
623 /// The proposed total fee for the closing transaction
624 pub fee_satoshis: u64,
625 /// A signature on the closing transaction
626 pub signature: Signature,
627 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
629 pub fee_range: Option<ClosingSignedFeeRange>,
632 /// An [`update_add_htlc`] message to be sent to or received from a peer.
634 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
635 #[derive(Clone, Debug, PartialEq, Eq)]
636 pub struct UpdateAddHTLC {
638 pub channel_id: [u8; 32],
641 /// The HTLC value in milli-satoshi
642 pub amount_msat: u64,
643 /// The payment hash, the pre-image of which controls HTLC redemption
644 pub payment_hash: PaymentHash,
645 /// The expiry height of the HTLC
646 pub cltv_expiry: u32,
647 pub(crate) onion_routing_packet: OnionPacket,
650 /// An onion message to be sent to or received from a peer.
652 // TODO: update with link to OM when they are merged into the BOLTs
653 #[derive(Clone, Debug, PartialEq, Eq)]
654 pub struct OnionMessage {
655 /// Used in decrypting the onion packet's payload.
656 pub blinding_point: PublicKey,
657 pub(crate) onion_routing_packet: onion_message::Packet,
660 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
662 /// [`update_fulfill_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
663 #[derive(Clone, Debug, PartialEq, Eq)]
664 pub struct UpdateFulfillHTLC {
666 pub channel_id: [u8; 32],
669 /// The pre-image of the payment hash, allowing HTLC redemption
670 pub payment_preimage: PaymentPreimage,
673 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
675 /// [`update_fail_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
676 #[derive(Clone, Debug, PartialEq, Eq)]
677 pub struct UpdateFailHTLC {
679 pub channel_id: [u8; 32],
682 pub(crate) reason: OnionErrorPacket,
685 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
687 /// [`update_fail_malformed_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#removing-an-htlc-update_fulfill_htlc-update_fail_htlc-and-update_fail_malformed_htlc
688 #[derive(Clone, Debug, PartialEq, Eq)]
689 pub struct UpdateFailMalformedHTLC {
691 pub channel_id: [u8; 32],
694 pub(crate) sha256_of_onion: [u8; 32],
696 pub failure_code: u16,
699 /// A [`commitment_signed`] message to be sent to or received from a peer.
701 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
702 #[derive(Clone, Debug, PartialEq, Eq)]
703 pub struct CommitmentSigned {
705 pub channel_id: [u8; 32],
706 /// A signature on the commitment transaction
707 pub signature: Signature,
708 /// Signatures on the HTLC transactions
709 pub htlc_signatures: Vec<Signature>,
711 /// The partial Taproot signature on the commitment transaction
712 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
715 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
717 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
718 #[derive(Clone, Debug, PartialEq, Eq)]
719 pub struct RevokeAndACK {
721 pub channel_id: [u8; 32],
722 /// The secret corresponding to the per-commitment point
723 pub per_commitment_secret: [u8; 32],
724 /// The next sender-broadcast commitment transaction's per-commitment point
725 pub next_per_commitment_point: PublicKey,
727 /// Musig nonce the recipient should use in their next commitment signature message
728 pub next_local_nonce: Option<musig2::types::PublicNonce>
731 /// An [`update_fee`] message to be sent to or received from a peer
733 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
734 #[derive(Clone, Debug, PartialEq, Eq)]
735 pub struct UpdateFee {
737 pub channel_id: [u8; 32],
738 /// Fee rate per 1000-weight of the transaction
739 pub feerate_per_kw: u32,
742 /// A [`channel_reestablish`] message to be sent to or received from a peer.
744 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
745 #[derive(Clone, Debug, PartialEq, Eq)]
746 pub struct ChannelReestablish {
748 pub channel_id: [u8; 32],
749 /// The next commitment number for the sender
750 pub next_local_commitment_number: u64,
751 /// The next commitment number for the recipient
752 pub next_remote_commitment_number: u64,
753 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
754 /// belonging to the recipient
755 pub your_last_per_commitment_secret: [u8; 32],
756 /// The sender's per-commitment point for their current commitment transaction
757 pub my_current_per_commitment_point: PublicKey,
758 /// The next funding transaction ID
759 pub next_funding_txid: Option<Txid>,
762 /// An [`announcement_signatures`] message to be sent to or received from a peer.
764 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
765 #[derive(Clone, Debug, PartialEq, Eq)]
766 pub struct AnnouncementSignatures {
768 pub channel_id: [u8; 32],
769 /// The short channel ID
770 pub short_channel_id: u64,
771 /// A signature by the node key
772 pub node_signature: Signature,
773 /// A signature by the funding key
774 pub bitcoin_signature: Signature,
777 /// An address which can be used to connect to a remote peer.
778 #[derive(Clone, Debug, PartialEq, Eq)]
779 pub enum NetAddress {
780 /// An IPv4 address/port on which the peer is listening.
782 /// The 4-byte IPv4 address
784 /// The port on which the node is listening
787 /// An IPv6 address/port on which the peer is listening.
789 /// The 16-byte IPv6 address
791 /// The port on which the node is listening
794 /// An old-style Tor onion address/port on which the peer is listening.
796 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
797 /// addresses. Thus, the details are not parsed here.
799 /// A new-style Tor onion address/port on which the peer is listening.
801 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
802 /// wrap as base32 and append ".onion".
804 /// The ed25519 long-term public key of the peer
805 ed25519_pubkey: [u8; 32],
806 /// The checksum of the pubkey and version, as included in the onion address
808 /// The version byte, as defined by the Tor Onion v3 spec.
810 /// The port on which the node is listening
813 /// A hostname/port on which the peer is listening.
815 /// The hostname on which the node is listening.
817 /// The port on which the node is listening.
822 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
824 pub(crate) fn get_id(&self) -> u8 {
826 &NetAddress::IPv4 {..} => { 1 },
827 &NetAddress::IPv6 {..} => { 2 },
828 &NetAddress::OnionV2(_) => { 3 },
829 &NetAddress::OnionV3 {..} => { 4 },
830 &NetAddress::Hostname {..} => { 5 },
834 /// Strict byte-length of address descriptor, 1-byte type not recorded
835 fn len(&self) -> u16 {
837 &NetAddress::IPv4 { .. } => { 6 },
838 &NetAddress::IPv6 { .. } => { 18 },
839 &NetAddress::OnionV2(_) => { 12 },
840 &NetAddress::OnionV3 { .. } => { 37 },
841 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
842 &NetAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
846 /// The maximum length of any address descriptor, not including the 1-byte type.
847 /// This maximum length is reached by a hostname address descriptor:
848 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
849 pub(crate) const MAX_LEN: u16 = 258;
852 impl Writeable for NetAddress {
853 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
855 &NetAddress::IPv4 { ref addr, ref port } => {
860 &NetAddress::IPv6 { ref addr, ref port } => {
865 &NetAddress::OnionV2(bytes) => {
867 bytes.write(writer)?;
869 &NetAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
871 ed25519_pubkey.write(writer)?;
872 checksum.write(writer)?;
873 version.write(writer)?;
876 &NetAddress::Hostname { ref hostname, ref port } => {
878 hostname.write(writer)?;
886 impl Readable for Result<NetAddress, u8> {
887 fn read<R: Read>(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
888 let byte = <u8 as Readable>::read(reader)?;
891 Ok(Ok(NetAddress::IPv4 {
892 addr: Readable::read(reader)?,
893 port: Readable::read(reader)?,
897 Ok(Ok(NetAddress::IPv6 {
898 addr: Readable::read(reader)?,
899 port: Readable::read(reader)?,
902 3 => Ok(Ok(NetAddress::OnionV2(Readable::read(reader)?))),
904 Ok(Ok(NetAddress::OnionV3 {
905 ed25519_pubkey: Readable::read(reader)?,
906 checksum: Readable::read(reader)?,
907 version: Readable::read(reader)?,
908 port: Readable::read(reader)?,
912 Ok(Ok(NetAddress::Hostname {
913 hostname: Readable::read(reader)?,
914 port: Readable::read(reader)?,
917 _ => return Ok(Err(byte)),
922 impl Readable for NetAddress {
923 fn read<R: Read>(reader: &mut R) -> Result<NetAddress, DecodeError> {
924 match Readable::read(reader) {
925 Ok(Ok(res)) => Ok(res),
926 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
932 /// Represents the set of gossip messages that require a signature from a node's identity key.
933 pub enum UnsignedGossipMessage<'a> {
934 /// An unsigned channel announcement.
935 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
936 /// An unsigned channel update.
937 ChannelUpdate(&'a UnsignedChannelUpdate),
938 /// An unsigned node announcement.
939 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
942 impl<'a> Writeable for UnsignedGossipMessage<'a> {
943 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
945 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
946 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
947 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
952 /// The unsigned part of a [`node_announcement`] message.
954 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
955 #[derive(Clone, Debug, PartialEq, Eq)]
956 pub struct UnsignedNodeAnnouncement {
957 /// The advertised features
958 pub features: NodeFeatures,
959 /// A strictly monotonic announcement counter, with gaps allowed
961 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
964 /// An RGB color for UI purposes
966 /// An alias, for UI purposes.
968 /// This should be sanitized before use. There is no guarantee of uniqueness.
969 pub alias: NodeAlias,
970 /// List of addresses on which this node is reachable
971 pub addresses: Vec<NetAddress>,
972 pub(crate) excess_address_data: Vec<u8>,
973 pub(crate) excess_data: Vec<u8>,
975 #[derive(Clone, Debug, PartialEq, Eq)]
976 /// A [`node_announcement`] message to be sent to or received from a peer.
978 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
979 pub struct NodeAnnouncement {
980 /// The signature by the node key
981 pub signature: Signature,
982 /// The actual content of the announcement
983 pub contents: UnsignedNodeAnnouncement,
986 /// The unsigned part of a [`channel_announcement`] message.
988 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
989 #[derive(Clone, Debug, PartialEq, Eq)]
990 pub struct UnsignedChannelAnnouncement {
991 /// The advertised channel features
992 pub features: ChannelFeatures,
993 /// The genesis hash of the blockchain where the channel is to be opened
994 pub chain_hash: BlockHash,
995 /// The short channel ID
996 pub short_channel_id: u64,
997 /// One of the two `node_id`s which are endpoints of this channel
998 pub node_id_1: NodeId,
999 /// The other of the two `node_id`s which are endpoints of this channel
1000 pub node_id_2: NodeId,
1001 /// The funding key for the first node
1002 pub bitcoin_key_1: NodeId,
1003 /// The funding key for the second node
1004 pub bitcoin_key_2: NodeId,
1005 pub(crate) excess_data: Vec<u8>,
1007 /// A [`channel_announcement`] message to be sent to or received from a peer.
1009 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1010 #[derive(Clone, Debug, PartialEq, Eq)]
1011 pub struct ChannelAnnouncement {
1012 /// Authentication of the announcement by the first public node
1013 pub node_signature_1: Signature,
1014 /// Authentication of the announcement by the second public node
1015 pub node_signature_2: Signature,
1016 /// Proof of funding UTXO ownership by the first public node
1017 pub bitcoin_signature_1: Signature,
1018 /// Proof of funding UTXO ownership by the second public node
1019 pub bitcoin_signature_2: Signature,
1020 /// The actual announcement
1021 pub contents: UnsignedChannelAnnouncement,
1024 /// The unsigned part of a [`channel_update`] message.
1026 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1027 #[derive(Clone, Debug, PartialEq, Eq)]
1028 pub struct UnsignedChannelUpdate {
1029 /// The genesis hash of the blockchain where the channel is to be opened
1030 pub chain_hash: BlockHash,
1031 /// The short channel ID
1032 pub short_channel_id: u64,
1033 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1037 /// The number of blocks such that if:
1038 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1039 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1040 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1041 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1042 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1043 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1044 /// constructing the route.
1045 pub cltv_expiry_delta: u16,
1046 /// The minimum HTLC size incoming to sender, in milli-satoshi
1047 pub htlc_minimum_msat: u64,
1048 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1050 /// This used to be optional.
1051 pub htlc_maximum_msat: u64,
1052 /// The base HTLC fee charged by sender, in milli-satoshi
1053 pub fee_base_msat: u32,
1054 /// The amount to fee multiplier, in micro-satoshi
1055 pub fee_proportional_millionths: u32,
1056 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1059 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1060 pub excess_data: Vec<u8>,
1062 /// A [`channel_update`] message to be sent to or received from a peer.
1064 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1065 #[derive(Clone, Debug, PartialEq, Eq)]
1066 pub struct ChannelUpdate {
1067 /// A signature of the channel update
1068 pub signature: Signature,
1069 /// The actual channel update
1070 pub contents: UnsignedChannelUpdate,
1073 /// A [`query_channel_range`] message is used to query a peer for channel
1074 /// UTXOs in a range of blocks. The recipient of a query makes a best
1075 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1078 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1079 #[derive(Clone, Debug, PartialEq, Eq)]
1080 pub struct QueryChannelRange {
1081 /// The genesis hash of the blockchain being queried
1082 pub chain_hash: BlockHash,
1083 /// The height of the first block for the channel UTXOs being queried
1084 pub first_blocknum: u32,
1085 /// The number of blocks to include in the query results
1086 pub number_of_blocks: u32,
1089 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1092 /// Multiple `reply_channel_range` messages can be sent in reply
1093 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1094 /// best effort to respond based on their local network view which may
1095 /// not be a perfect view of the network. The `short_channel_id`s in the
1096 /// reply are encoded. We only support `encoding_type=0` uncompressed
1097 /// serialization and do not support `encoding_type=1` zlib serialization.
1099 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1100 #[derive(Clone, Debug, PartialEq, Eq)]
1101 pub struct ReplyChannelRange {
1102 /// The genesis hash of the blockchain being queried
1103 pub chain_hash: BlockHash,
1104 /// The height of the first block in the range of the reply
1105 pub first_blocknum: u32,
1106 /// The number of blocks included in the range of the reply
1107 pub number_of_blocks: u32,
1108 /// True when this is the final reply for a query
1109 pub sync_complete: bool,
1110 /// The `short_channel_id`s in the channel range
1111 pub short_channel_ids: Vec<u64>,
1114 /// A [`query_short_channel_ids`] message is used to query a peer for
1115 /// routing gossip messages related to one or more `short_channel_id`s.
1117 /// The query recipient will reply with the latest, if available,
1118 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1119 /// it maintains for the requested `short_channel_id`s followed by a
1120 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1121 /// this query are encoded. We only support `encoding_type=0` uncompressed
1122 /// serialization and do not support `encoding_type=1` zlib serialization.
1124 /// [`query_short_channel_ids`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_short_channel_idsreply_short_channel_ids_end-messages
1125 #[derive(Clone, Debug, PartialEq, Eq)]
1126 pub struct QueryShortChannelIds {
1127 /// The genesis hash of the blockchain being queried
1128 pub chain_hash: BlockHash,
1129 /// The short_channel_ids that are being queried
1130 pub short_channel_ids: Vec<u64>,
1133 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1134 /// message. The query recipient makes a best
1135 /// effort to respond based on their local network view which may not be
1136 /// a perfect view of the network.
1138 /// [`reply_short_channel_ids_end`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_short_channel_idsreply_short_channel_ids_end-messages
1139 #[derive(Clone, Debug, PartialEq, Eq)]
1140 pub struct ReplyShortChannelIdsEnd {
1141 /// The genesis hash of the blockchain that was queried
1142 pub chain_hash: BlockHash,
1143 /// Indicates if the query recipient maintains up-to-date channel
1144 /// information for the `chain_hash`
1145 pub full_information: bool,
1148 /// A [`gossip_timestamp_filter`] message is used by a node to request
1149 /// gossip relay for messages in the requested time range when the
1150 /// `gossip_queries` feature has been negotiated.
1152 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1153 #[derive(Clone, Debug, PartialEq, Eq)]
1154 pub struct GossipTimestampFilter {
1155 /// The genesis hash of the blockchain for channel and node information
1156 pub chain_hash: BlockHash,
1157 /// The starting unix timestamp
1158 pub first_timestamp: u32,
1159 /// The range of information in seconds
1160 pub timestamp_range: u32,
1163 /// Encoding type for data compression of collections in gossip queries.
1165 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1166 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1168 Uncompressed = 0x00,
1171 /// Used to put an error message in a [`LightningError`].
1172 #[derive(Clone, Debug)]
1173 pub enum ErrorAction {
1174 /// The peer took some action which made us think they were useless. Disconnect them.
1176 /// An error message which we should make an effort to send before we disconnect.
1177 msg: Option<ErrorMessage>
1179 /// The peer did something harmless that we weren't able to process, just log and ignore
1180 // New code should *not* use this. New code must use IgnoreAndLog, below!
1182 /// The peer did something harmless that we weren't able to meaningfully process.
1183 /// If the error is logged, log it at the given level.
1184 IgnoreAndLog(logger::Level),
1185 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1186 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1187 /// our own channel announcements.
1188 IgnoreDuplicateGossip,
1189 /// The peer did something incorrect. Tell them.
1191 /// The message to send.
1194 /// The peer did something incorrect. Tell them without closing any channels.
1195 SendWarningMessage {
1196 /// The message to send.
1197 msg: WarningMessage,
1198 /// The peer may have done something harmless that we weren't able to meaningfully process,
1199 /// though we should still tell them about it.
1200 /// If this event is logged, log it at the given level.
1201 log_level: logger::Level,
1205 /// An Err type for failure to process messages.
1206 #[derive(Clone, Debug)]
1207 pub struct LightningError {
1208 /// A human-readable message describing the error
1210 /// The action which should be taken against the offending peer.
1211 pub action: ErrorAction,
1214 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1215 /// transaction updates if they were pending.
1216 #[derive(Clone, Debug, PartialEq, Eq)]
1217 pub struct CommitmentUpdate {
1218 /// `update_add_htlc` messages which should be sent
1219 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1220 /// `update_fulfill_htlc` messages which should be sent
1221 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1222 /// `update_fail_htlc` messages which should be sent
1223 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1224 /// `update_fail_malformed_htlc` messages which should be sent
1225 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1226 /// An `update_fee` message which should be sent
1227 pub update_fee: Option<UpdateFee>,
1228 /// A `commitment_signed` message which should be sent
1229 pub commitment_signed: CommitmentSigned,
1232 /// A trait to describe an object which can receive channel messages.
1234 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1235 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1236 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1238 /// Handle an incoming `open_channel` message from the given peer.
1239 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1240 /// Handle an incoming `open_channel2` message from the given peer.
1241 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1242 /// Handle an incoming `accept_channel` message from the given peer.
1243 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1244 /// Handle an incoming `accept_channel2` message from the given peer.
1245 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1246 /// Handle an incoming `funding_created` message from the given peer.
1247 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1248 /// Handle an incoming `funding_signed` message from the given peer.
1249 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1250 /// Handle an incoming `channel_ready` message from the given peer.
1251 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1254 /// Handle an incoming `shutdown` message from the given peer.
1255 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1256 /// Handle an incoming `closing_signed` message from the given peer.
1257 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1259 // Interactive channel construction
1260 /// Handle an incoming `tx_add_input message` from the given peer.
1261 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1262 /// Handle an incoming `tx_add_output` message from the given peer.
1263 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1264 /// Handle an incoming `tx_remove_input` message from the given peer.
1265 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1266 /// Handle an incoming `tx_remove_output` message from the given peer.
1267 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1268 /// Handle an incoming `tx_complete message` from the given peer.
1269 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1270 /// Handle an incoming `tx_signatures` message from the given peer.
1271 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1272 /// Handle an incoming `tx_init_rbf` message from the given peer.
1273 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1274 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1275 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1276 /// Handle an incoming `tx_abort message` from the given peer.
1277 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1280 /// Handle an incoming `update_add_htlc` message from the given peer.
1281 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1282 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1283 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1284 /// Handle an incoming `update_fail_htlc` message from the given peer.
1285 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1286 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1287 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1288 /// Handle an incoming `commitment_signed` message from the given peer.
1289 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1290 /// Handle an incoming `revoke_and_ack` message from the given peer.
1291 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1293 /// Handle an incoming `update_fee` message from the given peer.
1294 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1296 // Channel-to-announce:
1297 /// Handle an incoming `announcement_signatures` message from the given peer.
1298 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1300 // Connection loss/reestablish:
1301 /// Indicates a connection to the peer failed/an existing connection was lost.
1302 fn peer_disconnected(&self, their_node_id: &PublicKey);
1304 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1306 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1307 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1308 /// message handlers may still wish to communicate with this peer.
1309 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1310 /// Handle an incoming `channel_reestablish` message from the given peer.
1311 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1313 /// Handle an incoming `channel_update` message from the given peer.
1314 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1317 /// Handle an incoming `error` message from the given peer.
1318 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1320 // Handler information:
1321 /// Gets the node feature flags which this handler itself supports. All available handlers are
1322 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1323 /// which are broadcasted in our [`NodeAnnouncement`] message.
1324 fn provided_node_features(&self) -> NodeFeatures;
1326 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1327 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1328 /// which are sent in our [`Init`] message.
1330 /// Note that this method is called before [`Self::peer_connected`].
1331 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1334 /// A trait to describe an object which can receive routing messages.
1336 /// # Implementor DoS Warnings
1338 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1339 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1340 /// repeated disk I/O for queries accessing different parts of the network graph.
1341 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1342 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1343 /// `false` or returning an `Err` otherwise.
1344 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1345 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1346 /// or returning an `Err` otherwise.
1347 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1348 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1349 /// `false` or returning an `Err` otherwise.
1350 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1351 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1352 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1353 /// for a single channel.
1354 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1355 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1356 /// the node *after* the provided pubkey and including up to one announcement immediately
1357 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1358 /// If `None` is provided for `starting_point`, we start at the first node.
1359 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1360 /// Called when a connection is established with a peer. This can be used to
1361 /// perform routing table synchronization using a strategy defined by the
1364 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1365 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1366 /// message handlers may still wish to communicate with this peer.
1367 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1368 /// Handles the reply of a query we initiated to learn about channels
1369 /// for a given range of blocks. We can expect to receive one or more
1370 /// replies to a single query.
1371 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1372 /// Handles the reply of a query we initiated asking for routing gossip
1373 /// messages for a list of channels. We should receive this message when
1374 /// a node has completed its best effort to send us the pertaining routing
1375 /// gossip messages.
1376 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1377 /// Handles when a peer asks us to send a list of `short_channel_id`s
1378 /// for the requested range of blocks.
1379 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1380 /// Handles when a peer asks us to send routing gossip messages for a
1381 /// list of `short_channel_id`s.
1382 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1384 // Handler queueing status:
1385 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1386 /// pending some async action. While there is no guarantee of the rate of future messages, the
1387 /// caller should seek to reduce the rate of new gossip messages handled, especially
1388 /// [`ChannelAnnouncement`]s.
1389 fn processing_queue_high(&self) -> bool;
1391 // Handler information:
1392 /// Gets the node feature flags which this handler itself supports. All available handlers are
1393 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1394 /// which are broadcasted in our [`NodeAnnouncement`] message.
1395 fn provided_node_features(&self) -> NodeFeatures;
1396 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1397 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1398 /// which are sent in our [`Init`] message.
1400 /// Note that this method is called before [`Self::peer_connected`].
1401 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1404 /// A trait to describe an object that can receive onion messages.
1405 pub trait OnionMessageHandler : OnionMessageProvider {
1406 /// Handle an incoming `onion_message` message from the given peer.
1407 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1408 /// Called when a connection is established with a peer. Can be used to track which peers
1409 /// advertise onion message support and are online.
1411 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1412 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1413 /// message handlers may still wish to communicate with this peer.
1414 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1415 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1416 /// drop and refuse to forward onion messages to this peer.
1417 fn peer_disconnected(&self, their_node_id: &PublicKey);
1419 // Handler information:
1420 /// Gets the node feature flags which this handler itself supports. All available handlers are
1421 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1422 /// which are broadcasted in our [`NodeAnnouncement`] message.
1423 fn provided_node_features(&self) -> NodeFeatures;
1425 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1426 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1427 /// which are sent in our [`Init`] message.
1429 /// Note that this method is called before [`Self::peer_connected`].
1430 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1433 mod fuzzy_internal_msgs {
1434 use crate::prelude::*;
1435 use crate::ln::{PaymentPreimage, PaymentSecret};
1437 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1438 // them from untrusted input):
1440 pub(crate) struct FinalOnionHopData {
1441 pub(crate) payment_secret: PaymentSecret,
1442 /// The total value, in msat, of the payment as received by the ultimate recipient.
1443 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1444 pub(crate) total_msat: u64,
1447 pub(crate) enum OnionHopDataFormat {
1449 short_channel_id: u64,
1452 payment_data: Option<FinalOnionHopData>,
1453 payment_metadata: Option<Vec<u8>>,
1454 keysend_preimage: Option<PaymentPreimage>,
1458 pub struct OnionHopData {
1459 pub(crate) format: OnionHopDataFormat,
1460 /// The value, in msat, of the payment after this hop's fee is deducted.
1461 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1462 pub(crate) amt_to_forward: u64,
1463 pub(crate) outgoing_cltv_value: u32,
1466 pub struct DecodedOnionErrorPacket {
1467 pub(crate) hmac: [u8; 32],
1468 pub(crate) failuremsg: Vec<u8>,
1469 pub(crate) pad: Vec<u8>,
1473 pub use self::fuzzy_internal_msgs::*;
1474 #[cfg(not(fuzzing))]
1475 pub(crate) use self::fuzzy_internal_msgs::*;
1478 pub(crate) struct OnionPacket {
1479 pub(crate) version: u8,
1480 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1481 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1482 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1483 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1485 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1486 pub(crate) hop_data: [u8; 20*65],
1487 pub(crate) hmac: [u8; 32],
1490 impl onion_utils::Packet for OnionPacket {
1491 type Data = onion_utils::FixedSizeOnionPacket;
1492 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1495 public_key: Ok(pubkey),
1496 hop_data: hop_data.0,
1502 impl Eq for OnionPacket { }
1503 impl PartialEq for OnionPacket {
1504 fn eq(&self, other: &OnionPacket) -> bool {
1505 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1506 if i != j { return false; }
1508 self.version == other.version &&
1509 self.public_key == other.public_key &&
1510 self.hmac == other.hmac
1514 impl fmt::Debug for OnionPacket {
1515 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1516 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1520 #[derive(Clone, Debug, PartialEq, Eq)]
1521 pub(crate) struct OnionErrorPacket {
1522 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1523 // (TODO) We limit it in decode to much lower...
1524 pub(crate) data: Vec<u8>,
1527 impl fmt::Display for DecodeError {
1528 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1530 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1531 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1532 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1533 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1534 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1535 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1536 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1541 impl From<io::Error> for DecodeError {
1542 fn from(e: io::Error) -> Self {
1543 if e.kind() == io::ErrorKind::UnexpectedEof {
1544 DecodeError::ShortRead
1546 DecodeError::Io(e.kind())
1551 #[cfg(not(taproot))]
1552 impl_writeable_msg!(AcceptChannel, {
1553 temporary_channel_id,
1554 dust_limit_satoshis,
1555 max_htlc_value_in_flight_msat,
1556 channel_reserve_satoshis,
1562 revocation_basepoint,
1564 delayed_payment_basepoint,
1566 first_per_commitment_point,
1568 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1569 (1, channel_type, option),
1573 impl_writeable_msg!(AcceptChannel, {
1574 temporary_channel_id,
1575 dust_limit_satoshis,
1576 max_htlc_value_in_flight_msat,
1577 channel_reserve_satoshis,
1583 revocation_basepoint,
1585 delayed_payment_basepoint,
1587 first_per_commitment_point,
1589 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1590 (1, channel_type, option),
1591 (4, next_local_nonce, option),
1594 impl_writeable_msg!(AcceptChannelV2, {
1595 temporary_channel_id,
1597 dust_limit_satoshis,
1598 max_htlc_value_in_flight_msat,
1604 revocation_basepoint,
1606 delayed_payment_basepoint,
1608 first_per_commitment_point,
1609 second_per_commitment_point,
1611 (0, shutdown_scriptpubkey, option),
1612 (1, channel_type, option),
1613 (2, require_confirmed_inputs, option),
1616 impl_writeable_msg!(TxAddInput, {
1624 impl_writeable_msg!(TxAddOutput, {
1631 impl_writeable_msg!(TxRemoveInput, {
1636 impl_writeable_msg!(TxRemoveOutput, {
1641 impl_writeable_msg!(TxComplete, {
1645 impl_writeable_msg!(TxSignatures, {
1651 impl_writeable_msg!(TxInitRbf, {
1654 feerate_sat_per_1000_weight,
1656 (0, funding_output_contribution, option),
1659 impl_writeable_msg!(TxAckRbf, {
1662 (0, funding_output_contribution, option),
1665 impl_writeable_msg!(TxAbort, {
1670 impl_writeable_msg!(AnnouncementSignatures, {
1677 impl_writeable_msg!(ChannelReestablish, {
1679 next_local_commitment_number,
1680 next_remote_commitment_number,
1681 your_last_per_commitment_secret,
1682 my_current_per_commitment_point,
1684 (0, next_funding_txid, option),
1687 impl_writeable_msg!(ClosingSigned,
1688 { channel_id, fee_satoshis, signature },
1689 { (1, fee_range, option) }
1692 impl_writeable!(ClosingSignedFeeRange, {
1697 #[cfg(not(taproot))]
1698 impl_writeable_msg!(CommitmentSigned, {
1705 impl_writeable_msg!(CommitmentSigned, {
1710 (2, partial_signature_with_nonce, option)
1713 impl_writeable!(DecodedOnionErrorPacket, {
1719 #[cfg(not(taproot))]
1720 impl_writeable_msg!(FundingCreated, {
1721 temporary_channel_id,
1723 funding_output_index,
1727 impl_writeable_msg!(FundingCreated, {
1728 temporary_channel_id,
1730 funding_output_index,
1733 (2, partial_signature_with_nonce, option),
1734 (4, next_local_nonce, option)
1737 #[cfg(not(taproot))]
1738 impl_writeable_msg!(FundingSigned, {
1744 impl_writeable_msg!(FundingSigned, {
1748 (2, partial_signature_with_nonce, option)
1751 impl_writeable_msg!(ChannelReady, {
1753 next_per_commitment_point,
1755 (1, short_channel_id_alias, option),
1758 impl Writeable for Init {
1759 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1760 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1761 // our relevant feature bits. This keeps us compatible with old nodes.
1762 self.features.write_up_to_13(w)?;
1763 self.features.write(w)?;
1764 encode_tlv_stream!(w, {
1765 (3, self.remote_network_address, option)
1771 impl Readable for Init {
1772 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1773 let global_features: InitFeatures = Readable::read(r)?;
1774 let features: InitFeatures = Readable::read(r)?;
1775 let mut remote_network_address: Option<NetAddress> = None;
1776 decode_tlv_stream!(r, {
1777 (3, remote_network_address, option)
1780 features: features.or(global_features),
1781 remote_network_address,
1786 impl_writeable_msg!(OpenChannel, {
1788 temporary_channel_id,
1791 dust_limit_satoshis,
1792 max_htlc_value_in_flight_msat,
1793 channel_reserve_satoshis,
1799 revocation_basepoint,
1801 delayed_payment_basepoint,
1803 first_per_commitment_point,
1806 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1807 (1, channel_type, option),
1810 impl_writeable_msg!(OpenChannelV2, {
1812 temporary_channel_id,
1813 funding_feerate_sat_per_1000_weight,
1814 commitment_feerate_sat_per_1000_weight,
1816 dust_limit_satoshis,
1817 max_htlc_value_in_flight_msat,
1823 revocation_basepoint,
1825 delayed_payment_basepoint,
1827 first_per_commitment_point,
1828 second_per_commitment_point,
1831 (0, shutdown_scriptpubkey, option),
1832 (1, channel_type, option),
1833 (2, require_confirmed_inputs, option),
1836 #[cfg(not(taproot))]
1837 impl_writeable_msg!(RevokeAndACK, {
1839 per_commitment_secret,
1840 next_per_commitment_point
1844 impl_writeable_msg!(RevokeAndACK, {
1846 per_commitment_secret,
1847 next_per_commitment_point
1849 (4, next_local_nonce, option)
1852 impl_writeable_msg!(Shutdown, {
1857 impl_writeable_msg!(UpdateFailHTLC, {
1863 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1870 impl_writeable_msg!(UpdateFee, {
1875 impl_writeable_msg!(UpdateFulfillHTLC, {
1881 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1882 // serialization format in a way which assumes we know the total serialized length/message end
1884 impl_writeable!(OnionErrorPacket, {
1888 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1889 // serialization format in a way which assumes we know the total serialized length/message end
1891 impl Writeable for OnionPacket {
1892 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1893 self.version.write(w)?;
1894 match self.public_key {
1895 Ok(pubkey) => pubkey.write(w)?,
1896 Err(_) => [0u8;33].write(w)?,
1898 w.write_all(&self.hop_data)?;
1899 self.hmac.write(w)?;
1904 impl Readable for OnionPacket {
1905 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1907 version: Readable::read(r)?,
1909 let mut buf = [0u8;33];
1910 r.read_exact(&mut buf)?;
1911 PublicKey::from_slice(&buf)
1913 hop_data: Readable::read(r)?,
1914 hmac: Readable::read(r)?,
1919 impl_writeable_msg!(UpdateAddHTLC, {
1925 onion_routing_packet
1928 impl Readable for OnionMessage {
1929 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1930 let blinding_point: PublicKey = Readable::read(r)?;
1931 let len: u16 = Readable::read(r)?;
1932 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1933 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1936 onion_routing_packet,
1941 impl Writeable for OnionMessage {
1942 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1943 self.blinding_point.write(w)?;
1944 let onion_packet_len = self.onion_routing_packet.serialized_length();
1945 (onion_packet_len as u16).write(w)?;
1946 self.onion_routing_packet.write(w)?;
1951 impl Writeable for FinalOnionHopData {
1952 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1953 self.payment_secret.0.write(w)?;
1954 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1958 impl Readable for FinalOnionHopData {
1959 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1960 let secret: [u8; 32] = Readable::read(r)?;
1961 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1962 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1966 impl Writeable for OnionHopData {
1967 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1969 OnionHopDataFormat::NonFinalNode { short_channel_id } => {
1970 _encode_varint_length_prefixed_tlv!(w, {
1971 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1972 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1973 (6, short_channel_id, required)
1976 OnionHopDataFormat::FinalNode { ref payment_data, ref payment_metadata, ref keysend_preimage } => {
1977 _encode_varint_length_prefixed_tlv!(w, {
1978 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1979 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1980 (8, payment_data, option),
1981 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option),
1982 (5482373484, keysend_preimage, option)
1990 impl Readable for OnionHopData {
1991 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1992 let mut amt = HighZeroBytesDroppedBigSize(0u64);
1993 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
1994 let mut short_id: Option<u64> = None;
1995 let mut payment_data: Option<FinalOnionHopData> = None;
1996 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
1997 let mut keysend_preimage: Option<PaymentPreimage> = None;
1998 read_tlv_fields!(r, {
2000 (4, cltv_value, required),
2001 (6, short_id, option),
2002 (8, payment_data, option),
2003 (16, payment_metadata, option),
2004 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2005 (5482373484, keysend_preimage, option)
2008 let format = if let Some(short_channel_id) = short_id {
2009 if payment_data.is_some() { return Err(DecodeError::InvalidValue); }
2010 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
2011 OnionHopDataFormat::NonFinalNode {
2015 if let Some(data) = &payment_data {
2016 if data.total_msat > MAX_VALUE_MSAT {
2017 return Err(DecodeError::InvalidValue);
2020 OnionHopDataFormat::FinalNode {
2022 payment_metadata: payment_metadata.map(|w| w.0),
2027 if amt.0 > MAX_VALUE_MSAT {
2028 return Err(DecodeError::InvalidValue);
2032 amt_to_forward: amt.0,
2033 outgoing_cltv_value: cltv_value.0,
2038 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2039 // onion message packets.
2040 impl ReadableArgs<()> for OnionHopData {
2041 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2042 <Self as Readable>::read(r)
2046 impl Writeable for Ping {
2047 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2048 self.ponglen.write(w)?;
2049 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2054 impl Readable for Ping {
2055 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2057 ponglen: Readable::read(r)?,
2059 let byteslen = Readable::read(r)?;
2060 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2067 impl Writeable for Pong {
2068 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2069 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2074 impl Readable for Pong {
2075 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2078 let byteslen = Readable::read(r)?;
2079 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2086 impl Writeable for UnsignedChannelAnnouncement {
2087 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2088 self.features.write(w)?;
2089 self.chain_hash.write(w)?;
2090 self.short_channel_id.write(w)?;
2091 self.node_id_1.write(w)?;
2092 self.node_id_2.write(w)?;
2093 self.bitcoin_key_1.write(w)?;
2094 self.bitcoin_key_2.write(w)?;
2095 w.write_all(&self.excess_data[..])?;
2100 impl Readable for UnsignedChannelAnnouncement {
2101 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2103 features: Readable::read(r)?,
2104 chain_hash: Readable::read(r)?,
2105 short_channel_id: Readable::read(r)?,
2106 node_id_1: Readable::read(r)?,
2107 node_id_2: Readable::read(r)?,
2108 bitcoin_key_1: Readable::read(r)?,
2109 bitcoin_key_2: Readable::read(r)?,
2110 excess_data: read_to_end(r)?,
2115 impl_writeable!(ChannelAnnouncement, {
2118 bitcoin_signature_1,
2119 bitcoin_signature_2,
2123 impl Writeable for UnsignedChannelUpdate {
2124 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2125 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2126 const MESSAGE_FLAGS: u8 = 1;
2127 self.chain_hash.write(w)?;
2128 self.short_channel_id.write(w)?;
2129 self.timestamp.write(w)?;
2130 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2131 all_flags.write(w)?;
2132 self.cltv_expiry_delta.write(w)?;
2133 self.htlc_minimum_msat.write(w)?;
2134 self.fee_base_msat.write(w)?;
2135 self.fee_proportional_millionths.write(w)?;
2136 self.htlc_maximum_msat.write(w)?;
2137 w.write_all(&self.excess_data[..])?;
2142 impl Readable for UnsignedChannelUpdate {
2143 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2145 chain_hash: Readable::read(r)?,
2146 short_channel_id: Readable::read(r)?,
2147 timestamp: Readable::read(r)?,
2149 let flags: u16 = Readable::read(r)?;
2150 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2153 cltv_expiry_delta: Readable::read(r)?,
2154 htlc_minimum_msat: Readable::read(r)?,
2155 fee_base_msat: Readable::read(r)?,
2156 fee_proportional_millionths: Readable::read(r)?,
2157 htlc_maximum_msat: Readable::read(r)?,
2158 excess_data: read_to_end(r)?,
2163 impl_writeable!(ChannelUpdate, {
2168 impl Writeable for ErrorMessage {
2169 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2170 self.channel_id.write(w)?;
2171 (self.data.len() as u16).write(w)?;
2172 w.write_all(self.data.as_bytes())?;
2177 impl Readable for ErrorMessage {
2178 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2180 channel_id: Readable::read(r)?,
2182 let sz: usize = <u16 as Readable>::read(r)? as usize;
2183 let mut data = Vec::with_capacity(sz);
2185 r.read_exact(&mut data)?;
2186 match String::from_utf8(data) {
2188 Err(_) => return Err(DecodeError::InvalidValue),
2195 impl Writeable for WarningMessage {
2196 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2197 self.channel_id.write(w)?;
2198 (self.data.len() as u16).write(w)?;
2199 w.write_all(self.data.as_bytes())?;
2204 impl Readable for WarningMessage {
2205 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2207 channel_id: Readable::read(r)?,
2209 let sz: usize = <u16 as Readable>::read(r)? as usize;
2210 let mut data = Vec::with_capacity(sz);
2212 r.read_exact(&mut data)?;
2213 match String::from_utf8(data) {
2215 Err(_) => return Err(DecodeError::InvalidValue),
2222 impl Writeable for UnsignedNodeAnnouncement {
2223 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2224 self.features.write(w)?;
2225 self.timestamp.write(w)?;
2226 self.node_id.write(w)?;
2227 w.write_all(&self.rgb)?;
2228 self.alias.write(w)?;
2230 let mut addr_len = 0;
2231 for addr in self.addresses.iter() {
2232 addr_len += 1 + addr.len();
2234 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2235 for addr in self.addresses.iter() {
2238 w.write_all(&self.excess_address_data[..])?;
2239 w.write_all(&self.excess_data[..])?;
2244 impl Readable for UnsignedNodeAnnouncement {
2245 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2246 let features: NodeFeatures = Readable::read(r)?;
2247 let timestamp: u32 = Readable::read(r)?;
2248 let node_id: NodeId = Readable::read(r)?;
2249 let mut rgb = [0; 3];
2250 r.read_exact(&mut rgb)?;
2251 let alias: NodeAlias = Readable::read(r)?;
2253 let addr_len: u16 = Readable::read(r)?;
2254 let mut addresses: Vec<NetAddress> = Vec::new();
2255 let mut addr_readpos = 0;
2256 let mut excess = false;
2257 let mut excess_byte = 0;
2259 if addr_len <= addr_readpos { break; }
2260 match Readable::read(r) {
2262 if addr_len < addr_readpos + 1 + addr.len() {
2263 return Err(DecodeError::BadLengthDescriptor);
2265 addr_readpos += (1 + addr.len()) as u16;
2266 addresses.push(addr);
2268 Ok(Err(unknown_descriptor)) => {
2270 excess_byte = unknown_descriptor;
2273 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2274 Err(e) => return Err(e),
2278 let mut excess_data = vec![];
2279 let excess_address_data = if addr_readpos < addr_len {
2280 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2281 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2283 excess_address_data[0] = excess_byte;
2288 excess_data.push(excess_byte);
2292 excess_data.extend(read_to_end(r)?.iter());
2293 Ok(UnsignedNodeAnnouncement {
2300 excess_address_data,
2306 impl_writeable!(NodeAnnouncement, {
2311 impl Readable for QueryShortChannelIds {
2312 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2313 let chain_hash: BlockHash = Readable::read(r)?;
2315 let encoding_len: u16 = Readable::read(r)?;
2316 let encoding_type: u8 = Readable::read(r)?;
2318 // Must be encoding_type=0 uncompressed serialization. We do not
2319 // support encoding_type=1 zlib serialization.
2320 if encoding_type != EncodingType::Uncompressed as u8 {
2321 return Err(DecodeError::UnsupportedCompression);
2324 // We expect the encoding_len to always includes the 1-byte
2325 // encoding_type and that short_channel_ids are 8-bytes each
2326 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2327 return Err(DecodeError::InvalidValue);
2330 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2331 // less the 1-byte encoding_type
2332 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2333 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2334 for _ in 0..short_channel_id_count {
2335 short_channel_ids.push(Readable::read(r)?);
2338 Ok(QueryShortChannelIds {
2345 impl Writeable for QueryShortChannelIds {
2346 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2347 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2348 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2350 self.chain_hash.write(w)?;
2351 encoding_len.write(w)?;
2353 // We only support type=0 uncompressed serialization
2354 (EncodingType::Uncompressed as u8).write(w)?;
2356 for scid in self.short_channel_ids.iter() {
2364 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2369 impl QueryChannelRange {
2370 /// Calculates the overflow safe ending block height for the query.
2372 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2373 pub fn end_blocknum(&self) -> u32 {
2374 match self.first_blocknum.checked_add(self.number_of_blocks) {
2375 Some(block) => block,
2376 None => u32::max_value(),
2381 impl_writeable_msg!(QueryChannelRange, {
2387 impl Readable for ReplyChannelRange {
2388 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2389 let chain_hash: BlockHash = Readable::read(r)?;
2390 let first_blocknum: u32 = Readable::read(r)?;
2391 let number_of_blocks: u32 = Readable::read(r)?;
2392 let sync_complete: bool = Readable::read(r)?;
2394 let encoding_len: u16 = Readable::read(r)?;
2395 let encoding_type: u8 = Readable::read(r)?;
2397 // Must be encoding_type=0 uncompressed serialization. We do not
2398 // support encoding_type=1 zlib serialization.
2399 if encoding_type != EncodingType::Uncompressed as u8 {
2400 return Err(DecodeError::UnsupportedCompression);
2403 // We expect the encoding_len to always includes the 1-byte
2404 // encoding_type and that short_channel_ids are 8-bytes each
2405 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2406 return Err(DecodeError::InvalidValue);
2409 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2410 // less the 1-byte encoding_type
2411 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2412 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2413 for _ in 0..short_channel_id_count {
2414 short_channel_ids.push(Readable::read(r)?);
2417 Ok(ReplyChannelRange {
2427 impl Writeable for ReplyChannelRange {
2428 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2429 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2430 self.chain_hash.write(w)?;
2431 self.first_blocknum.write(w)?;
2432 self.number_of_blocks.write(w)?;
2433 self.sync_complete.write(w)?;
2435 encoding_len.write(w)?;
2436 (EncodingType::Uncompressed as u8).write(w)?;
2437 for scid in self.short_channel_ids.iter() {
2445 impl_writeable_msg!(GossipTimestampFilter, {
2453 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2455 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2456 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2457 use crate::ln::msgs::{self, TransactionU16LenLimited};
2458 use crate::ln::msgs::{FinalOnionHopData, OnionErrorPacket, OnionHopDataFormat};
2459 use crate::routing::gossip::{NodeAlias, NodeId};
2460 use crate::util::ser::{Writeable, Readable, Hostname};
2462 use bitcoin::hashes::hex::FromHex;
2463 use bitcoin::util::address::Address;
2464 use bitcoin::network::constants::Network;
2465 use bitcoin::blockdata::script::Builder;
2466 use bitcoin::blockdata::opcodes;
2467 use bitcoin::hash_types::{Txid, BlockHash};
2469 use bitcoin::secp256k1::{PublicKey,SecretKey};
2470 use bitcoin::secp256k1::{Secp256k1, Message};
2472 use crate::io::{self, Cursor};
2473 use crate::prelude::*;
2474 use core::convert::TryFrom;
2475 use core::str::FromStr;
2477 use crate::chain::transaction::OutPoint;
2480 fn encoding_channel_reestablish() {
2482 let secp_ctx = Secp256k1::new();
2483 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2486 let cr = msgs::ChannelReestablish {
2487 channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2488 next_local_commitment_number: 3,
2489 next_remote_commitment_number: 4,
2490 your_last_per_commitment_secret: [9;32],
2491 my_current_per_commitment_point: public_key,
2492 next_funding_txid: None,
2495 let encoded_value = cr.encode();
2499 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, // channel_id
2500 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2501 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2502 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // your_last_per_commitment_secret
2503 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, // my_current_per_commitment_point
2509 fn encoding_channel_reestablish_with_next_funding_txid() {
2511 let secp_ctx = Secp256k1::new();
2512 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2515 let cr = msgs::ChannelReestablish {
2516 channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2517 next_local_commitment_number: 3,
2518 next_remote_commitment_number: 4,
2519 your_last_per_commitment_secret: [9;32],
2520 my_current_per_commitment_point: public_key,
2521 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2522 48, 167, 250, 69, 152, 48, 103, 172, 164, 99, 59, 19, 23, 11, 92, 84, 15, 80, 4, 12, 98, 82, 75, 31, 201, 11, 91, 23, 98, 23, 53, 124,
2526 let encoded_value = cr.encode();
2530 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, // channel_id
2531 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2532 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2533 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // your_last_per_commitment_secret
2534 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, // my_current_per_commitment_point
2535 0, // Type (next_funding_txid)
2537 48, 167, 250, 69, 152, 48, 103, 172, 164, 99, 59, 19, 23, 11, 92, 84, 15, 80, 4, 12, 98, 82, 75, 31, 201, 11, 91, 23, 98, 23, 53, 124, // Value
2542 macro_rules! get_keys_from {
2543 ($slice: expr, $secp_ctx: expr) => {
2545 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2546 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2552 macro_rules! get_sig_on {
2553 ($privkey: expr, $ctx: expr, $string: expr) => {
2555 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2556 $ctx.sign_ecdsa(&sighash, &$privkey)
2562 fn encoding_announcement_signatures() {
2563 let secp_ctx = Secp256k1::new();
2564 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2565 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2566 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2567 let announcement_signatures = msgs::AnnouncementSignatures {
2568 channel_id: [4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0],
2569 short_channel_id: 2316138423780173,
2570 node_signature: sig_1,
2571 bitcoin_signature: sig_2,
2574 let encoded_value = announcement_signatures.encode();
2575 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2578 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2579 let secp_ctx = Secp256k1::new();
2580 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2581 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2582 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2583 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2584 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2585 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2586 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2587 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2588 let mut features = ChannelFeatures::empty();
2589 if unknown_features_bits {
2590 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2592 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2594 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2595 short_channel_id: 2316138423780173,
2596 node_id_1: NodeId::from_pubkey(&pubkey_1),
2597 node_id_2: NodeId::from_pubkey(&pubkey_2),
2598 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2599 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2600 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2602 let channel_announcement = msgs::ChannelAnnouncement {
2603 node_signature_1: sig_1,
2604 node_signature_2: sig_2,
2605 bitcoin_signature_1: sig_3,
2606 bitcoin_signature_2: sig_4,
2607 contents: unsigned_channel_announcement,
2609 let encoded_value = channel_announcement.encode();
2610 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2611 if unknown_features_bits {
2612 target_value.append(&mut hex::decode("0002ffff").unwrap());
2614 target_value.append(&mut hex::decode("0000").unwrap());
2616 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2617 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2619 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2621 assert_eq!(encoded_value, target_value);
2625 fn encoding_channel_announcement() {
2626 do_encoding_channel_announcement(true, false);
2627 do_encoding_channel_announcement(false, true);
2628 do_encoding_channel_announcement(false, false);
2629 do_encoding_channel_announcement(true, true);
2632 fn do_encoding_node_announcement(unknown_features_bits: bool, ipv4: bool, ipv6: bool, onionv2: bool, onionv3: bool, hostname: bool, excess_address_data: bool, excess_data: bool) {
2633 let secp_ctx = Secp256k1::new();
2634 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2635 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2636 let features = if unknown_features_bits {
2637 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2639 // Set to some features we may support
2640 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2642 let mut addresses = Vec::new();
2644 addresses.push(msgs::NetAddress::IPv4 {
2645 addr: [255, 254, 253, 252],
2650 addresses.push(msgs::NetAddress::IPv6 {
2651 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2656 addresses.push(msgs::NetAddress::OnionV2(
2657 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2661 addresses.push(msgs::NetAddress::OnionV3 {
2662 ed25519_pubkey: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224],
2669 addresses.push(msgs::NetAddress::Hostname {
2670 hostname: Hostname::try_from(String::from("host")).unwrap(),
2674 let mut addr_len = 0;
2675 for addr in &addresses {
2676 addr_len += addr.len() + 1;
2678 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2680 timestamp: 20190119,
2681 node_id: NodeId::from_pubkey(&pubkey_1),
2683 alias: NodeAlias([16;32]),
2685 excess_address_data: if excess_address_data { vec![33, 108, 40, 11, 83, 149, 162, 84, 110, 126, 75, 38, 99, 224, 79, 129, 22, 34, 241, 90, 79, 146, 232, 58, 162, 233, 43, 162, 165, 115, 193, 57, 20, 44, 84, 174, 99, 7, 42, 30, 193, 238, 125, 192, 192, 75, 222, 92, 132, 120, 6, 23, 42, 160, 92, 146, 194, 42, 232, 227, 8, 209, 210, 105] } else { Vec::new() },
2686 excess_data: if excess_data { vec![59, 18, 204, 25, 92, 224, 162, 209, 189, 166, 168, 139, 239, 161, 159, 160, 127, 81, 202, 167, 92, 232, 56, 55, 242, 137, 101, 96, 11, 138, 172, 171, 8, 85, 255, 176, 231, 65, 236, 95, 124, 65, 66, 30, 152, 41, 169, 212, 134, 17, 200, 200, 49, 247, 27, 229, 234, 115, 230, 101, 148, 151, 127, 253] } else { Vec::new() },
2688 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2689 let node_announcement = msgs::NodeAnnouncement {
2691 contents: unsigned_node_announcement,
2693 let encoded_value = node_announcement.encode();
2694 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2695 if unknown_features_bits {
2696 target_value.append(&mut hex::decode("0002ffff").unwrap());
2698 target_value.append(&mut hex::decode("000122").unwrap());
2700 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2701 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2703 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2706 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2709 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2712 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2715 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2717 if excess_address_data {
2718 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2721 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2723 assert_eq!(encoded_value, target_value);
2727 fn encoding_node_announcement() {
2728 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2729 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2730 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2731 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2732 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2733 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2734 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2735 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2736 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2737 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2740 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2741 let secp_ctx = Secp256k1::new();
2742 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2743 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2744 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2745 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2746 short_channel_id: 2316138423780173,
2747 timestamp: 20190119,
2748 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2749 cltv_expiry_delta: 144,
2750 htlc_minimum_msat: 1000000,
2751 htlc_maximum_msat: 131355275467161,
2752 fee_base_msat: 10000,
2753 fee_proportional_millionths: 20,
2754 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2756 let channel_update = msgs::ChannelUpdate {
2758 contents: unsigned_channel_update
2760 let encoded_value = channel_update.encode();
2761 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2762 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2763 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2764 target_value.append(&mut hex::decode("01").unwrap());
2765 target_value.append(&mut hex::decode("00").unwrap());
2767 let flag = target_value.last_mut().unwrap();
2771 let flag = target_value.last_mut().unwrap();
2772 *flag = *flag | 1 << 1;
2774 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2775 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2777 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2779 assert_eq!(encoded_value, target_value);
2783 fn encoding_channel_update() {
2784 do_encoding_channel_update(false, false, false);
2785 do_encoding_channel_update(false, false, true);
2786 do_encoding_channel_update(true, false, false);
2787 do_encoding_channel_update(true, false, true);
2788 do_encoding_channel_update(false, true, false);
2789 do_encoding_channel_update(false, true, true);
2790 do_encoding_channel_update(true, true, false);
2791 do_encoding_channel_update(true, true, true);
2794 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2795 let secp_ctx = Secp256k1::new();
2796 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2797 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2798 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2799 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2800 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2801 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2802 let open_channel = msgs::OpenChannel {
2803 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2804 temporary_channel_id: [2; 32],
2805 funding_satoshis: 1311768467284833366,
2806 push_msat: 2536655962884945560,
2807 dust_limit_satoshis: 3608586615801332854,
2808 max_htlc_value_in_flight_msat: 8517154655701053848,
2809 channel_reserve_satoshis: 8665828695742877976,
2810 htlc_minimum_msat: 2316138423780173,
2811 feerate_per_kw: 821716,
2812 to_self_delay: 49340,
2813 max_accepted_htlcs: 49340,
2814 funding_pubkey: pubkey_1,
2815 revocation_basepoint: pubkey_2,
2816 payment_point: pubkey_3,
2817 delayed_payment_basepoint: pubkey_4,
2818 htlc_basepoint: pubkey_5,
2819 first_per_commitment_point: pubkey_6,
2820 channel_flags: if random_bit { 1 << 5 } else { 0 },
2821 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2822 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2824 let encoded_value = open_channel.encode();
2825 let mut target_value = Vec::new();
2826 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2827 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2829 target_value.append(&mut hex::decode("20").unwrap());
2831 target_value.append(&mut hex::decode("00").unwrap());
2834 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2837 target_value.append(&mut hex::decode("0100").unwrap());
2839 assert_eq!(encoded_value, target_value);
2843 fn encoding_open_channel() {
2844 do_encoding_open_channel(false, false, false);
2845 do_encoding_open_channel(false, false, true);
2846 do_encoding_open_channel(false, true, false);
2847 do_encoding_open_channel(false, true, true);
2848 do_encoding_open_channel(true, false, false);
2849 do_encoding_open_channel(true, false, true);
2850 do_encoding_open_channel(true, true, false);
2851 do_encoding_open_channel(true, true, true);
2854 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2855 let secp_ctx = Secp256k1::new();
2856 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2857 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2858 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2859 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2860 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2861 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2862 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2863 let open_channelv2 = msgs::OpenChannelV2 {
2864 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2865 temporary_channel_id: [2; 32],
2866 funding_feerate_sat_per_1000_weight: 821716,
2867 commitment_feerate_sat_per_1000_weight: 821716,
2868 funding_satoshis: 1311768467284833366,
2869 dust_limit_satoshis: 3608586615801332854,
2870 max_htlc_value_in_flight_msat: 8517154655701053848,
2871 htlc_minimum_msat: 2316138423780173,
2872 to_self_delay: 49340,
2873 max_accepted_htlcs: 49340,
2874 locktime: 305419896,
2875 funding_pubkey: pubkey_1,
2876 revocation_basepoint: pubkey_2,
2877 payment_basepoint: pubkey_3,
2878 delayed_payment_basepoint: pubkey_4,
2879 htlc_basepoint: pubkey_5,
2880 first_per_commitment_point: pubkey_6,
2881 second_per_commitment_point: pubkey_7,
2882 channel_flags: if random_bit { 1 << 5 } else { 0 },
2883 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2884 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2885 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2887 let encoded_value = open_channelv2.encode();
2888 let mut target_value = Vec::new();
2889 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2890 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2891 target_value.append(&mut hex::decode("000c89d4").unwrap());
2892 target_value.append(&mut hex::decode("000c89d4").unwrap());
2893 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2894 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2895 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2896 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2897 target_value.append(&mut hex::decode("c0bc").unwrap());
2898 target_value.append(&mut hex::decode("c0bc").unwrap());
2899 target_value.append(&mut hex::decode("12345678").unwrap());
2900 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2901 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2902 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2903 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2904 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2905 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2906 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2909 target_value.append(&mut hex::decode("20").unwrap());
2911 target_value.append(&mut hex::decode("00").unwrap());
2914 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2915 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2918 target_value.append(&mut hex::decode("0100").unwrap());
2920 if require_confirmed_inputs {
2921 target_value.append(&mut hex::decode("0200").unwrap());
2923 assert_eq!(encoded_value, target_value);
2927 fn encoding_open_channelv2() {
2928 do_encoding_open_channelv2(false, false, false, false);
2929 do_encoding_open_channelv2(false, false, false, true);
2930 do_encoding_open_channelv2(false, false, true, false);
2931 do_encoding_open_channelv2(false, false, true, true);
2932 do_encoding_open_channelv2(false, true, false, false);
2933 do_encoding_open_channelv2(false, true, false, true);
2934 do_encoding_open_channelv2(false, true, true, false);
2935 do_encoding_open_channelv2(false, true, true, true);
2936 do_encoding_open_channelv2(true, false, false, false);
2937 do_encoding_open_channelv2(true, false, false, true);
2938 do_encoding_open_channelv2(true, false, true, false);
2939 do_encoding_open_channelv2(true, false, true, true);
2940 do_encoding_open_channelv2(true, true, false, false);
2941 do_encoding_open_channelv2(true, true, false, true);
2942 do_encoding_open_channelv2(true, true, true, false);
2943 do_encoding_open_channelv2(true, true, true, true);
2946 fn do_encoding_accept_channel(shutdown: bool) {
2947 let secp_ctx = Secp256k1::new();
2948 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2949 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2950 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2951 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2952 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2953 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2954 let accept_channel = msgs::AcceptChannel {
2955 temporary_channel_id: [2; 32],
2956 dust_limit_satoshis: 1311768467284833366,
2957 max_htlc_value_in_flight_msat: 2536655962884945560,
2958 channel_reserve_satoshis: 3608586615801332854,
2959 htlc_minimum_msat: 2316138423780173,
2960 minimum_depth: 821716,
2961 to_self_delay: 49340,
2962 max_accepted_htlcs: 49340,
2963 funding_pubkey: pubkey_1,
2964 revocation_basepoint: pubkey_2,
2965 payment_point: pubkey_3,
2966 delayed_payment_basepoint: pubkey_4,
2967 htlc_basepoint: pubkey_5,
2968 first_per_commitment_point: pubkey_6,
2969 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2972 next_local_nonce: None,
2974 let encoded_value = accept_channel.encode();
2975 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2977 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2979 assert_eq!(encoded_value, target_value);
2983 fn encoding_accept_channel() {
2984 do_encoding_accept_channel(false);
2985 do_encoding_accept_channel(true);
2988 fn do_encoding_accept_channelv2(shutdown: bool) {
2989 let secp_ctx = Secp256k1::new();
2990 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2991 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2992 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2993 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2994 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2995 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2996 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2997 let accept_channelv2 = msgs::AcceptChannelV2 {
2998 temporary_channel_id: [2; 32],
2999 funding_satoshis: 1311768467284833366,
3000 dust_limit_satoshis: 1311768467284833366,
3001 max_htlc_value_in_flight_msat: 2536655962884945560,
3002 htlc_minimum_msat: 2316138423780173,
3003 minimum_depth: 821716,
3004 to_self_delay: 49340,
3005 max_accepted_htlcs: 49340,
3006 funding_pubkey: pubkey_1,
3007 revocation_basepoint: pubkey_2,
3008 payment_basepoint: pubkey_3,
3009 delayed_payment_basepoint: pubkey_4,
3010 htlc_basepoint: pubkey_5,
3011 first_per_commitment_point: pubkey_6,
3012 second_per_commitment_point: pubkey_7,
3013 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3015 require_confirmed_inputs: None,
3017 let encoded_value = accept_channelv2.encode();
3018 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3019 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3020 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3021 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3022 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3023 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3024 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3025 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3026 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3027 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3028 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3029 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3030 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3031 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3032 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3034 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3035 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3037 assert_eq!(encoded_value, target_value);
3041 fn encoding_accept_channelv2() {
3042 do_encoding_accept_channelv2(false);
3043 do_encoding_accept_channelv2(true);
3047 fn encoding_funding_created() {
3048 let secp_ctx = Secp256k1::new();
3049 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3050 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3051 let funding_created = msgs::FundingCreated {
3052 temporary_channel_id: [2; 32],
3053 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3054 funding_output_index: 255,
3057 partial_signature_with_nonce: None,
3059 next_local_nonce: None,
3061 let encoded_value = funding_created.encode();
3062 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3063 assert_eq!(encoded_value, target_value);
3067 fn encoding_funding_signed() {
3068 let secp_ctx = Secp256k1::new();
3069 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3070 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3071 let funding_signed = msgs::FundingSigned {
3072 channel_id: [2; 32],
3075 partial_signature_with_nonce: None,
3077 let encoded_value = funding_signed.encode();
3078 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3079 assert_eq!(encoded_value, target_value);
3083 fn encoding_channel_ready() {
3084 let secp_ctx = Secp256k1::new();
3085 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3086 let channel_ready = msgs::ChannelReady {
3087 channel_id: [2; 32],
3088 next_per_commitment_point: pubkey_1,
3089 short_channel_id_alias: None,
3091 let encoded_value = channel_ready.encode();
3092 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3093 assert_eq!(encoded_value, target_value);
3097 fn encoding_tx_add_input() {
3098 let tx_add_input = msgs::TxAddInput {
3099 channel_id: [2; 32],
3100 serial_id: 4886718345,
3101 prevtx: TransactionU16LenLimited::new(Transaction {
3103 lock_time: PackedLockTime(0),
3105 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3106 script_sig: Script::new(),
3107 sequence: Sequence(0xfffffffd),
3108 witness: Witness::from_vec(vec![
3109 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3110 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3115 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3119 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3123 prevtx_out: 305419896,
3124 sequence: 305419896,
3126 let encoded_value = tx_add_input.encode();
3127 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3128 assert_eq!(encoded_value, target_value);
3132 fn encoding_tx_add_output() {
3133 let tx_add_output = msgs::TxAddOutput {
3134 channel_id: [2; 32],
3135 serial_id: 4886718345,
3137 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3139 let encoded_value = tx_add_output.encode();
3140 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3141 assert_eq!(encoded_value, target_value);
3145 fn encoding_tx_remove_input() {
3146 let tx_remove_input = msgs::TxRemoveInput {
3147 channel_id: [2; 32],
3148 serial_id: 4886718345,
3150 let encoded_value = tx_remove_input.encode();
3151 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3152 assert_eq!(encoded_value, target_value);
3156 fn encoding_tx_remove_output() {
3157 let tx_remove_output = msgs::TxRemoveOutput {
3158 channel_id: [2; 32],
3159 serial_id: 4886718345,
3161 let encoded_value = tx_remove_output.encode();
3162 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3163 assert_eq!(encoded_value, target_value);
3167 fn encoding_tx_complete() {
3168 let tx_complete = msgs::TxComplete {
3169 channel_id: [2; 32],
3171 let encoded_value = tx_complete.encode();
3172 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3173 assert_eq!(encoded_value, target_value);
3177 fn encoding_tx_signatures() {
3178 let tx_signatures = msgs::TxSignatures {
3179 channel_id: [2; 32],
3180 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3182 Witness::from_vec(vec![
3183 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3184 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3185 Witness::from_vec(vec![
3186 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3187 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3190 let encoded_value = tx_signatures.encode();
3191 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3192 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3193 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3195 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3196 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3197 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3198 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3199 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3200 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3202 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3203 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3204 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3205 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3206 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3207 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3208 assert_eq!(encoded_value, target_value);
3211 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3212 let tx_init_rbf = msgs::TxInitRbf {
3213 channel_id: [2; 32],
3214 locktime: 305419896,
3215 feerate_sat_per_1000_weight: 20190119,
3216 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3218 let encoded_value = tx_init_rbf.encode();
3219 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3220 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3221 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3222 if let Some((_, target)) = funding_value_with_hex_target {
3223 target_value.push(0x00); // Type
3224 target_value.push(target.len() as u8 / 2); // Length
3225 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3227 assert_eq!(encoded_value, target_value);
3231 fn encoding_tx_init_rbf() {
3232 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3233 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3234 do_encoding_tx_init_rbf(None);
3237 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3238 let tx_ack_rbf = msgs::TxAckRbf {
3239 channel_id: [2; 32],
3240 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3242 let encoded_value = tx_ack_rbf.encode();
3243 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3244 if let Some((_, target)) = funding_value_with_hex_target {
3245 target_value.push(0x00); // Type
3246 target_value.push(target.len() as u8 / 2); // Length
3247 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3249 assert_eq!(encoded_value, target_value);
3253 fn encoding_tx_ack_rbf() {
3254 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3255 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3256 do_encoding_tx_ack_rbf(None);
3260 fn encoding_tx_abort() {
3261 let tx_abort = msgs::TxAbort {
3262 channel_id: [2; 32],
3263 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3265 let encoded_value = tx_abort.encode();
3266 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3267 assert_eq!(encoded_value, target_value);
3270 fn do_encoding_shutdown(script_type: u8) {
3271 let secp_ctx = Secp256k1::new();
3272 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3273 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3274 let shutdown = msgs::Shutdown {
3275 channel_id: [2; 32],
3277 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3278 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3279 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3280 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3282 let encoded_value = shutdown.encode();
3283 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3284 if script_type == 1 {
3285 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3286 } else if script_type == 2 {
3287 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3288 } else if script_type == 3 {
3289 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3290 } else if script_type == 4 {
3291 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3293 assert_eq!(encoded_value, target_value);
3297 fn encoding_shutdown() {
3298 do_encoding_shutdown(1);
3299 do_encoding_shutdown(2);
3300 do_encoding_shutdown(3);
3301 do_encoding_shutdown(4);
3305 fn encoding_closing_signed() {
3306 let secp_ctx = Secp256k1::new();
3307 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3308 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3309 let closing_signed = msgs::ClosingSigned {
3310 channel_id: [2; 32],
3311 fee_satoshis: 2316138423780173,
3315 let encoded_value = closing_signed.encode();
3316 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3317 assert_eq!(encoded_value, target_value);
3318 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3320 let closing_signed_with_range = msgs::ClosingSigned {
3321 channel_id: [2; 32],
3322 fee_satoshis: 2316138423780173,
3324 fee_range: Some(msgs::ClosingSignedFeeRange {
3325 min_fee_satoshis: 0xdeadbeef,
3326 max_fee_satoshis: 0x1badcafe01234567,
3329 let encoded_value_with_range = closing_signed_with_range.encode();
3330 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3331 assert_eq!(encoded_value_with_range, target_value_with_range);
3332 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3333 closing_signed_with_range);
3337 fn encoding_update_add_htlc() {
3338 let secp_ctx = Secp256k1::new();
3339 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3340 let onion_routing_packet = msgs::OnionPacket {
3342 public_key: Ok(pubkey_1),
3343 hop_data: [1; 20*65],
3346 let update_add_htlc = msgs::UpdateAddHTLC {
3347 channel_id: [2; 32],
3348 htlc_id: 2316138423780173,
3349 amount_msat: 3608586615801332854,
3350 payment_hash: PaymentHash([1; 32]),
3351 cltv_expiry: 821716,
3352 onion_routing_packet
3354 let encoded_value = update_add_htlc.encode();
3355 let target_value = hex::decode("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").unwrap();
3356 assert_eq!(encoded_value, target_value);
3360 fn encoding_update_fulfill_htlc() {
3361 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3362 channel_id: [2; 32],
3363 htlc_id: 2316138423780173,
3364 payment_preimage: PaymentPreimage([1; 32]),
3366 let encoded_value = update_fulfill_htlc.encode();
3367 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3368 assert_eq!(encoded_value, target_value);
3372 fn encoding_update_fail_htlc() {
3373 let reason = OnionErrorPacket {
3374 data: [1; 32].to_vec(),
3376 let update_fail_htlc = msgs::UpdateFailHTLC {
3377 channel_id: [2; 32],
3378 htlc_id: 2316138423780173,
3381 let encoded_value = update_fail_htlc.encode();
3382 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3383 assert_eq!(encoded_value, target_value);
3387 fn encoding_update_fail_malformed_htlc() {
3388 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3389 channel_id: [2; 32],
3390 htlc_id: 2316138423780173,
3391 sha256_of_onion: [1; 32],
3394 let encoded_value = update_fail_malformed_htlc.encode();
3395 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3396 assert_eq!(encoded_value, target_value);
3399 fn do_encoding_commitment_signed(htlcs: bool) {
3400 let secp_ctx = Secp256k1::new();
3401 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3402 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3403 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3404 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3405 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3406 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3407 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3408 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3409 let commitment_signed = msgs::CommitmentSigned {
3410 channel_id: [2; 32],
3412 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3414 partial_signature_with_nonce: None,
3416 let encoded_value = commitment_signed.encode();
3417 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3419 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3421 target_value.append(&mut hex::decode("0000").unwrap());
3423 assert_eq!(encoded_value, target_value);
3427 fn encoding_commitment_signed() {
3428 do_encoding_commitment_signed(true);
3429 do_encoding_commitment_signed(false);
3433 fn encoding_revoke_and_ack() {
3434 let secp_ctx = Secp256k1::new();
3435 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3436 let raa = msgs::RevokeAndACK {
3437 channel_id: [2; 32],
3438 per_commitment_secret: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
3439 next_per_commitment_point: pubkey_1,
3441 next_local_nonce: None,
3443 let encoded_value = raa.encode();
3444 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3445 assert_eq!(encoded_value, target_value);
3449 fn encoding_update_fee() {
3450 let update_fee = msgs::UpdateFee {
3451 channel_id: [2; 32],
3452 feerate_per_kw: 20190119,
3454 let encoded_value = update_fee.encode();
3455 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3456 assert_eq!(encoded_value, target_value);
3460 fn encoding_init() {
3461 assert_eq!(msgs::Init {
3462 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3463 remote_network_address: None,
3464 }.encode(), hex::decode("00023fff0003ffffff").unwrap());
3465 assert_eq!(msgs::Init {
3466 features: InitFeatures::from_le_bytes(vec![0xFF]),
3467 remote_network_address: None,
3468 }.encode(), hex::decode("0001ff0001ff").unwrap());
3469 assert_eq!(msgs::Init {
3470 features: InitFeatures::from_le_bytes(vec![]),
3471 remote_network_address: None,
3472 }.encode(), hex::decode("00000000").unwrap());
3474 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3475 remote_network_address: Some(msgs::NetAddress::IPv4 {
3476 addr: [127, 0, 0, 1],
3480 let encoded_value = init_msg.encode();
3481 let target_value = hex::decode("000000000307017f00000103e8").unwrap();
3482 assert_eq!(encoded_value, target_value);
3483 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3487 fn encoding_error() {
3488 let error = msgs::ErrorMessage {
3489 channel_id: [2; 32],
3490 data: String::from("rust-lightning"),
3492 let encoded_value = error.encode();
3493 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3494 assert_eq!(encoded_value, target_value);
3498 fn encoding_warning() {
3499 let error = msgs::WarningMessage {
3500 channel_id: [2; 32],
3501 data: String::from("rust-lightning"),
3503 let encoded_value = error.encode();
3504 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3505 assert_eq!(encoded_value, target_value);
3509 fn encoding_ping() {
3510 let ping = msgs::Ping {
3514 let encoded_value = ping.encode();
3515 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3516 assert_eq!(encoded_value, target_value);
3520 fn encoding_pong() {
3521 let pong = msgs::Pong {
3524 let encoded_value = pong.encode();
3525 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3526 assert_eq!(encoded_value, target_value);
3530 fn encoding_nonfinal_onion_hop_data() {
3531 let mut msg = msgs::OnionHopData {
3532 format: OnionHopDataFormat::NonFinalNode {
3533 short_channel_id: 0xdeadbeef1bad1dea,
3535 amt_to_forward: 0x0badf00d01020304,
3536 outgoing_cltv_value: 0xffffffff,
3538 let encoded_value = msg.encode();
3539 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3540 assert_eq!(encoded_value, target_value);
3541 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3542 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = msg.format {
3543 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3544 } else { panic!(); }
3545 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3546 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3550 fn encoding_final_onion_hop_data() {
3551 let mut msg = msgs::OnionHopData {
3552 format: OnionHopDataFormat::FinalNode {
3554 payment_metadata: None,
3555 keysend_preimage: None,
3557 amt_to_forward: 0x0badf00d01020304,
3558 outgoing_cltv_value: 0xffffffff,
3560 let encoded_value = msg.encode();
3561 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3562 assert_eq!(encoded_value, target_value);
3563 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3564 if let OnionHopDataFormat::FinalNode { payment_data: None, .. } = msg.format { } else { panic!(); }
3565 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3566 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3570 fn encoding_final_onion_hop_data_with_secret() {
3571 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3572 let mut msg = msgs::OnionHopData {
3573 format: OnionHopDataFormat::FinalNode {
3574 payment_data: Some(FinalOnionHopData {
3575 payment_secret: expected_payment_secret,
3576 total_msat: 0x1badca1f
3578 payment_metadata: None,
3579 keysend_preimage: None,
3581 amt_to_forward: 0x0badf00d01020304,
3582 outgoing_cltv_value: 0xffffffff,
3584 let encoded_value = msg.encode();
3585 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3586 assert_eq!(encoded_value, target_value);
3587 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3588 if let OnionHopDataFormat::FinalNode {
3589 payment_data: Some(FinalOnionHopData {
3591 total_msat: 0x1badca1f
3593 payment_metadata: None,
3594 keysend_preimage: None,
3596 assert_eq!(payment_secret, expected_payment_secret);
3597 } else { panic!(); }
3598 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3599 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3603 fn query_channel_range_end_blocknum() {
3604 let tests: Vec<(u32, u32, u32)> = vec![
3605 (10000, 1500, 11500),
3606 (0, 0xffffffff, 0xffffffff),
3607 (1, 0xffffffff, 0xffffffff),
3610 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3611 let sut = msgs::QueryChannelRange {
3612 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3616 assert_eq!(sut.end_blocknum(), expected);
3621 fn encoding_query_channel_range() {
3622 let mut query_channel_range = msgs::QueryChannelRange {
3623 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3624 first_blocknum: 100000,
3625 number_of_blocks: 1500,
3627 let encoded_value = query_channel_range.encode();
3628 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3629 assert_eq!(encoded_value, target_value);
3631 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3632 assert_eq!(query_channel_range.first_blocknum, 100000);
3633 assert_eq!(query_channel_range.number_of_blocks, 1500);
3637 fn encoding_reply_channel_range() {
3638 do_encoding_reply_channel_range(0);
3639 do_encoding_reply_channel_range(1);
3642 fn do_encoding_reply_channel_range(encoding_type: u8) {
3643 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3644 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3645 let mut reply_channel_range = msgs::ReplyChannelRange {
3646 chain_hash: expected_chain_hash,
3647 first_blocknum: 756230,
3648 number_of_blocks: 1500,
3649 sync_complete: true,
3650 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3653 if encoding_type == 0 {
3654 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3655 let encoded_value = reply_channel_range.encode();
3656 assert_eq!(encoded_value, target_value);
3658 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3659 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3660 assert_eq!(reply_channel_range.first_blocknum, 756230);
3661 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3662 assert_eq!(reply_channel_range.sync_complete, true);
3663 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3664 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3665 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3667 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3668 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3669 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3674 fn encoding_query_short_channel_ids() {
3675 do_encoding_query_short_channel_ids(0);
3676 do_encoding_query_short_channel_ids(1);
3679 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3680 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3681 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3682 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3683 chain_hash: expected_chain_hash,
3684 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3687 if encoding_type == 0 {
3688 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3689 let encoded_value = query_short_channel_ids.encode();
3690 assert_eq!(encoded_value, target_value);
3692 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3693 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3694 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3695 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3696 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3698 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3699 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3700 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3705 fn encoding_reply_short_channel_ids_end() {
3706 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3707 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3708 chain_hash: expected_chain_hash,
3709 full_information: true,
3711 let encoded_value = reply_short_channel_ids_end.encode();
3712 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3713 assert_eq!(encoded_value, target_value);
3715 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3716 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3717 assert_eq!(reply_short_channel_ids_end.full_information, true);
3721 fn encoding_gossip_timestamp_filter(){
3722 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3723 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3724 chain_hash: expected_chain_hash,
3725 first_timestamp: 1590000000,
3726 timestamp_range: 0xffff_ffff,
3728 let encoded_value = gossip_timestamp_filter.encode();
3729 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3730 assert_eq!(encoded_value, target_value);
3732 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3733 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3734 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3735 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3739 fn decode_onion_hop_data_len_as_bigsize() {
3740 // Tests that we can decode an onion payload that is >253 bytes.
3741 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3742 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3745 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3746 // payload length to be encoded over multiple bytes rather than a single u8.
3747 let big_payload = encode_big_payload().unwrap();
3748 let mut rd = Cursor::new(&big_payload[..]);
3749 <msgs::OnionHopData as Readable>::read(&mut rd).unwrap();
3751 // see above test, needs to be a separate method for use of the serialization macros.
3752 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3753 use crate::util::ser::HighZeroBytesDroppedBigSize;
3754 let payload = msgs::OnionHopData {
3755 format: OnionHopDataFormat::NonFinalNode {
3756 short_channel_id: 0xdeadbeef1bad1dea,
3758 amt_to_forward: 1000,
3759 outgoing_cltv_value: 0xffffffff,
3761 let mut encoded_payload = Vec::new();
3762 let test_bytes = vec![42u8; 1000];
3763 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = payload.format {
3764 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3765 (1, test_bytes, vec_type),
3766 (2, HighZeroBytesDroppedBigSize(payload.amt_to_forward), required),
3767 (4, HighZeroBytesDroppedBigSize(payload.outgoing_cltv_value), required),
3768 (6, short_channel_id, required)