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 `accept_channel` message from the given peer.
1241 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1242 /// Handle an incoming `funding_created` message from the given peer.
1243 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1244 /// Handle an incoming `funding_signed` message from the given peer.
1245 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1246 /// Handle an incoming `channel_ready` message from the given peer.
1247 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1250 /// Handle an incoming `shutdown` message from the given peer.
1251 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1252 /// Handle an incoming `closing_signed` message from the given peer.
1253 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1256 /// Handle an incoming `update_add_htlc` message from the given peer.
1257 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1258 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1259 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1260 /// Handle an incoming `update_fail_htlc` message from the given peer.
1261 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1262 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1263 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1264 /// Handle an incoming `commitment_signed` message from the given peer.
1265 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1266 /// Handle an incoming `revoke_and_ack` message from the given peer.
1267 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1269 /// Handle an incoming `update_fee` message from the given peer.
1270 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1272 // Channel-to-announce:
1273 /// Handle an incoming `announcement_signatures` message from the given peer.
1274 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1276 // Connection loss/reestablish:
1277 /// Indicates a connection to the peer failed/an existing connection was lost.
1278 fn peer_disconnected(&self, their_node_id: &PublicKey);
1280 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1282 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1283 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1284 /// message handlers may still wish to communicate with this peer.
1285 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1286 /// Handle an incoming `channel_reestablish` message from the given peer.
1287 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1289 /// Handle an incoming `channel_update` message from the given peer.
1290 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1293 /// Handle an incoming `error` message from the given peer.
1294 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1296 // Handler information:
1297 /// Gets the node feature flags which this handler itself supports. All available handlers are
1298 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1299 /// which are broadcasted in our [`NodeAnnouncement`] message.
1300 fn provided_node_features(&self) -> NodeFeatures;
1302 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1303 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1304 /// which are sent in our [`Init`] message.
1306 /// Note that this method is called before [`Self::peer_connected`].
1307 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1310 /// A trait to describe an object which can receive routing messages.
1312 /// # Implementor DoS Warnings
1314 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1315 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1316 /// repeated disk I/O for queries accessing different parts of the network graph.
1317 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1318 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1319 /// `false` or returning an `Err` otherwise.
1320 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1321 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1322 /// or returning an `Err` otherwise.
1323 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1324 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1325 /// `false` or returning an `Err` otherwise.
1326 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1327 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1328 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1329 /// for a single channel.
1330 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1331 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1332 /// the node *after* the provided pubkey and including up to one announcement immediately
1333 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1334 /// If `None` is provided for `starting_point`, we start at the first node.
1335 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1336 /// Called when a connection is established with a peer. This can be used to
1337 /// perform routing table synchronization using a strategy defined by the
1340 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1341 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1342 /// message handlers may still wish to communicate with this peer.
1343 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1344 /// Handles the reply of a query we initiated to learn about channels
1345 /// for a given range of blocks. We can expect to receive one or more
1346 /// replies to a single query.
1347 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1348 /// Handles the reply of a query we initiated asking for routing gossip
1349 /// messages for a list of channels. We should receive this message when
1350 /// a node has completed its best effort to send us the pertaining routing
1351 /// gossip messages.
1352 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1353 /// Handles when a peer asks us to send a list of `short_channel_id`s
1354 /// for the requested range of blocks.
1355 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1356 /// Handles when a peer asks us to send routing gossip messages for a
1357 /// list of `short_channel_id`s.
1358 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1360 // Handler queueing status:
1361 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1362 /// pending some async action. While there is no guarantee of the rate of future messages, the
1363 /// caller should seek to reduce the rate of new gossip messages handled, especially
1364 /// [`ChannelAnnouncement`]s.
1365 fn processing_queue_high(&self) -> bool;
1367 // Handler information:
1368 /// Gets the node feature flags which this handler itself supports. All available handlers are
1369 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1370 /// which are broadcasted in our [`NodeAnnouncement`] message.
1371 fn provided_node_features(&self) -> NodeFeatures;
1372 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1373 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1374 /// which are sent in our [`Init`] message.
1376 /// Note that this method is called before [`Self::peer_connected`].
1377 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1380 /// A trait to describe an object that can receive onion messages.
1381 pub trait OnionMessageHandler : OnionMessageProvider {
1382 /// Handle an incoming `onion_message` message from the given peer.
1383 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1384 /// Called when a connection is established with a peer. Can be used to track which peers
1385 /// advertise onion message support and are online.
1387 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1388 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1389 /// message handlers may still wish to communicate with this peer.
1390 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1391 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1392 /// drop and refuse to forward onion messages to this peer.
1393 fn peer_disconnected(&self, their_node_id: &PublicKey);
1395 // Handler information:
1396 /// Gets the node feature flags which this handler itself supports. All available handlers are
1397 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1398 /// which are broadcasted in our [`NodeAnnouncement`] message.
1399 fn provided_node_features(&self) -> NodeFeatures;
1401 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1402 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1403 /// which are sent in our [`Init`] message.
1405 /// Note that this method is called before [`Self::peer_connected`].
1406 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1409 mod fuzzy_internal_msgs {
1410 use crate::prelude::*;
1411 use crate::ln::{PaymentPreimage, PaymentSecret};
1413 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1414 // them from untrusted input):
1416 pub(crate) struct FinalOnionHopData {
1417 pub(crate) payment_secret: PaymentSecret,
1418 /// The total value, in msat, of the payment as received by the ultimate recipient.
1419 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1420 pub(crate) total_msat: u64,
1423 pub(crate) enum OnionHopDataFormat {
1425 short_channel_id: u64,
1428 payment_data: Option<FinalOnionHopData>,
1429 payment_metadata: Option<Vec<u8>>,
1430 keysend_preimage: Option<PaymentPreimage>,
1434 pub struct OnionHopData {
1435 pub(crate) format: OnionHopDataFormat,
1436 /// The value, in msat, of the payment after this hop's fee is deducted.
1437 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1438 pub(crate) amt_to_forward: u64,
1439 pub(crate) outgoing_cltv_value: u32,
1442 pub struct DecodedOnionErrorPacket {
1443 pub(crate) hmac: [u8; 32],
1444 pub(crate) failuremsg: Vec<u8>,
1445 pub(crate) pad: Vec<u8>,
1449 pub use self::fuzzy_internal_msgs::*;
1450 #[cfg(not(fuzzing))]
1451 pub(crate) use self::fuzzy_internal_msgs::*;
1454 pub(crate) struct OnionPacket {
1455 pub(crate) version: u8,
1456 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1457 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1458 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1459 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1461 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1462 pub(crate) hop_data: [u8; 20*65],
1463 pub(crate) hmac: [u8; 32],
1466 impl onion_utils::Packet for OnionPacket {
1467 type Data = onion_utils::FixedSizeOnionPacket;
1468 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1471 public_key: Ok(pubkey),
1472 hop_data: hop_data.0,
1478 impl Eq for OnionPacket { }
1479 impl PartialEq for OnionPacket {
1480 fn eq(&self, other: &OnionPacket) -> bool {
1481 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1482 if i != j { return false; }
1484 self.version == other.version &&
1485 self.public_key == other.public_key &&
1486 self.hmac == other.hmac
1490 impl fmt::Debug for OnionPacket {
1491 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1492 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1496 #[derive(Clone, Debug, PartialEq, Eq)]
1497 pub(crate) struct OnionErrorPacket {
1498 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1499 // (TODO) We limit it in decode to much lower...
1500 pub(crate) data: Vec<u8>,
1503 impl fmt::Display for DecodeError {
1504 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1506 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1507 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1508 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1509 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1510 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1511 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1512 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1517 impl From<io::Error> for DecodeError {
1518 fn from(e: io::Error) -> Self {
1519 if e.kind() == io::ErrorKind::UnexpectedEof {
1520 DecodeError::ShortRead
1522 DecodeError::Io(e.kind())
1527 #[cfg(not(taproot))]
1528 impl_writeable_msg!(AcceptChannel, {
1529 temporary_channel_id,
1530 dust_limit_satoshis,
1531 max_htlc_value_in_flight_msat,
1532 channel_reserve_satoshis,
1538 revocation_basepoint,
1540 delayed_payment_basepoint,
1542 first_per_commitment_point,
1544 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1545 (1, channel_type, option),
1549 impl_writeable_msg!(AcceptChannel, {
1550 temporary_channel_id,
1551 dust_limit_satoshis,
1552 max_htlc_value_in_flight_msat,
1553 channel_reserve_satoshis,
1559 revocation_basepoint,
1561 delayed_payment_basepoint,
1563 first_per_commitment_point,
1565 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1566 (1, channel_type, option),
1567 (4, next_local_nonce, option),
1570 impl_writeable_msg!(AcceptChannelV2, {
1571 temporary_channel_id,
1573 dust_limit_satoshis,
1574 max_htlc_value_in_flight_msat,
1580 revocation_basepoint,
1582 delayed_payment_basepoint,
1584 first_per_commitment_point,
1585 second_per_commitment_point,
1587 (0, shutdown_scriptpubkey, option),
1588 (1, channel_type, option),
1589 (2, require_confirmed_inputs, option),
1592 impl_writeable_msg!(TxAddInput, {
1600 impl_writeable_msg!(TxAddOutput, {
1607 impl_writeable_msg!(TxRemoveInput, {
1612 impl_writeable_msg!(TxRemoveOutput, {
1617 impl_writeable_msg!(TxComplete, {
1621 impl_writeable_msg!(TxSignatures, {
1627 impl_writeable_msg!(TxInitRbf, {
1630 feerate_sat_per_1000_weight,
1632 (0, funding_output_contribution, option),
1635 impl_writeable_msg!(TxAckRbf, {
1638 (0, funding_output_contribution, option),
1641 impl_writeable_msg!(TxAbort, {
1646 impl_writeable_msg!(AnnouncementSignatures, {
1653 impl_writeable_msg!(ChannelReestablish, {
1655 next_local_commitment_number,
1656 next_remote_commitment_number,
1657 your_last_per_commitment_secret,
1658 my_current_per_commitment_point,
1660 (0, next_funding_txid, option),
1663 impl_writeable_msg!(ClosingSigned,
1664 { channel_id, fee_satoshis, signature },
1665 { (1, fee_range, option) }
1668 impl_writeable!(ClosingSignedFeeRange, {
1673 #[cfg(not(taproot))]
1674 impl_writeable_msg!(CommitmentSigned, {
1681 impl_writeable_msg!(CommitmentSigned, {
1686 (2, partial_signature_with_nonce, option)
1689 impl_writeable!(DecodedOnionErrorPacket, {
1695 #[cfg(not(taproot))]
1696 impl_writeable_msg!(FundingCreated, {
1697 temporary_channel_id,
1699 funding_output_index,
1703 impl_writeable_msg!(FundingCreated, {
1704 temporary_channel_id,
1706 funding_output_index,
1709 (2, partial_signature_with_nonce, option),
1710 (4, next_local_nonce, option)
1713 #[cfg(not(taproot))]
1714 impl_writeable_msg!(FundingSigned, {
1720 impl_writeable_msg!(FundingSigned, {
1724 (2, partial_signature_with_nonce, option)
1727 impl_writeable_msg!(ChannelReady, {
1729 next_per_commitment_point,
1731 (1, short_channel_id_alias, option),
1734 impl Writeable for Init {
1735 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1736 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1737 // our relevant feature bits. This keeps us compatible with old nodes.
1738 self.features.write_up_to_13(w)?;
1739 self.features.write(w)?;
1740 encode_tlv_stream!(w, {
1741 (3, self.remote_network_address, option)
1747 impl Readable for Init {
1748 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1749 let global_features: InitFeatures = Readable::read(r)?;
1750 let features: InitFeatures = Readable::read(r)?;
1751 let mut remote_network_address: Option<NetAddress> = None;
1752 decode_tlv_stream!(r, {
1753 (3, remote_network_address, option)
1756 features: features.or(global_features),
1757 remote_network_address,
1762 impl_writeable_msg!(OpenChannel, {
1764 temporary_channel_id,
1767 dust_limit_satoshis,
1768 max_htlc_value_in_flight_msat,
1769 channel_reserve_satoshis,
1775 revocation_basepoint,
1777 delayed_payment_basepoint,
1779 first_per_commitment_point,
1782 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1783 (1, channel_type, option),
1786 impl_writeable_msg!(OpenChannelV2, {
1788 temporary_channel_id,
1789 funding_feerate_sat_per_1000_weight,
1790 commitment_feerate_sat_per_1000_weight,
1792 dust_limit_satoshis,
1793 max_htlc_value_in_flight_msat,
1799 revocation_basepoint,
1801 delayed_payment_basepoint,
1803 first_per_commitment_point,
1804 second_per_commitment_point,
1807 (0, shutdown_scriptpubkey, option),
1808 (1, channel_type, option),
1809 (2, require_confirmed_inputs, option),
1812 #[cfg(not(taproot))]
1813 impl_writeable_msg!(RevokeAndACK, {
1815 per_commitment_secret,
1816 next_per_commitment_point
1820 impl_writeable_msg!(RevokeAndACK, {
1822 per_commitment_secret,
1823 next_per_commitment_point
1825 (4, next_local_nonce, option)
1828 impl_writeable_msg!(Shutdown, {
1833 impl_writeable_msg!(UpdateFailHTLC, {
1839 impl_writeable_msg!(UpdateFailMalformedHTLC, {
1846 impl_writeable_msg!(UpdateFee, {
1851 impl_writeable_msg!(UpdateFulfillHTLC, {
1857 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1858 // serialization format in a way which assumes we know the total serialized length/message end
1860 impl_writeable!(OnionErrorPacket, {
1864 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
1865 // serialization format in a way which assumes we know the total serialized length/message end
1867 impl Writeable for OnionPacket {
1868 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1869 self.version.write(w)?;
1870 match self.public_key {
1871 Ok(pubkey) => pubkey.write(w)?,
1872 Err(_) => [0u8;33].write(w)?,
1874 w.write_all(&self.hop_data)?;
1875 self.hmac.write(w)?;
1880 impl Readable for OnionPacket {
1881 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1883 version: Readable::read(r)?,
1885 let mut buf = [0u8;33];
1886 r.read_exact(&mut buf)?;
1887 PublicKey::from_slice(&buf)
1889 hop_data: Readable::read(r)?,
1890 hmac: Readable::read(r)?,
1895 impl_writeable_msg!(UpdateAddHTLC, {
1901 onion_routing_packet
1904 impl Readable for OnionMessage {
1905 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1906 let blinding_point: PublicKey = Readable::read(r)?;
1907 let len: u16 = Readable::read(r)?;
1908 let mut packet_reader = FixedLengthReader::new(r, len as u64);
1909 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
1912 onion_routing_packet,
1917 impl Writeable for OnionMessage {
1918 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1919 self.blinding_point.write(w)?;
1920 let onion_packet_len = self.onion_routing_packet.serialized_length();
1921 (onion_packet_len as u16).write(w)?;
1922 self.onion_routing_packet.write(w)?;
1927 impl Writeable for FinalOnionHopData {
1928 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1929 self.payment_secret.0.write(w)?;
1930 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
1934 impl Readable for FinalOnionHopData {
1935 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1936 let secret: [u8; 32] = Readable::read(r)?;
1937 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
1938 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
1942 impl Writeable for OnionHopData {
1943 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1945 OnionHopDataFormat::NonFinalNode { short_channel_id } => {
1946 _encode_varint_length_prefixed_tlv!(w, {
1947 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1948 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1949 (6, short_channel_id, required)
1952 OnionHopDataFormat::FinalNode { ref payment_data, ref payment_metadata, ref keysend_preimage } => {
1953 _encode_varint_length_prefixed_tlv!(w, {
1954 (2, HighZeroBytesDroppedBigSize(self.amt_to_forward), required),
1955 (4, HighZeroBytesDroppedBigSize(self.outgoing_cltv_value), required),
1956 (8, payment_data, option),
1957 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option),
1958 (5482373484, keysend_preimage, option)
1966 impl Readable for OnionHopData {
1967 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1968 let mut amt = HighZeroBytesDroppedBigSize(0u64);
1969 let mut cltv_value = HighZeroBytesDroppedBigSize(0u32);
1970 let mut short_id: Option<u64> = None;
1971 let mut payment_data: Option<FinalOnionHopData> = None;
1972 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
1973 let mut keysend_preimage: Option<PaymentPreimage> = None;
1974 read_tlv_fields!(r, {
1976 (4, cltv_value, required),
1977 (6, short_id, option),
1978 (8, payment_data, option),
1979 (16, payment_metadata, option),
1980 // See https://github.com/lightning/blips/blob/master/blip-0003.md
1981 (5482373484, keysend_preimage, option)
1984 let format = if let Some(short_channel_id) = short_id {
1985 if payment_data.is_some() { return Err(DecodeError::InvalidValue); }
1986 if payment_metadata.is_some() { return Err(DecodeError::InvalidValue); }
1987 OnionHopDataFormat::NonFinalNode {
1991 if let Some(data) = &payment_data {
1992 if data.total_msat > MAX_VALUE_MSAT {
1993 return Err(DecodeError::InvalidValue);
1996 OnionHopDataFormat::FinalNode {
1998 payment_metadata: payment_metadata.map(|w| w.0),
2003 if amt.0 > MAX_VALUE_MSAT {
2004 return Err(DecodeError::InvalidValue);
2008 amt_to_forward: amt.0,
2009 outgoing_cltv_value: cltv_value.0,
2014 // ReadableArgs because we need onion_utils::decode_next_hop to accommodate payment packets and
2015 // onion message packets.
2016 impl ReadableArgs<()> for OnionHopData {
2017 fn read<R: Read>(r: &mut R, _arg: ()) -> Result<Self, DecodeError> {
2018 <Self as Readable>::read(r)
2022 impl Writeable for Ping {
2023 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2024 self.ponglen.write(w)?;
2025 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2030 impl Readable for Ping {
2031 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2033 ponglen: Readable::read(r)?,
2035 let byteslen = Readable::read(r)?;
2036 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2043 impl Writeable for Pong {
2044 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2045 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2050 impl Readable for Pong {
2051 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2054 let byteslen = Readable::read(r)?;
2055 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2062 impl Writeable for UnsignedChannelAnnouncement {
2063 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2064 self.features.write(w)?;
2065 self.chain_hash.write(w)?;
2066 self.short_channel_id.write(w)?;
2067 self.node_id_1.write(w)?;
2068 self.node_id_2.write(w)?;
2069 self.bitcoin_key_1.write(w)?;
2070 self.bitcoin_key_2.write(w)?;
2071 w.write_all(&self.excess_data[..])?;
2076 impl Readable for UnsignedChannelAnnouncement {
2077 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2079 features: Readable::read(r)?,
2080 chain_hash: Readable::read(r)?,
2081 short_channel_id: Readable::read(r)?,
2082 node_id_1: Readable::read(r)?,
2083 node_id_2: Readable::read(r)?,
2084 bitcoin_key_1: Readable::read(r)?,
2085 bitcoin_key_2: Readable::read(r)?,
2086 excess_data: read_to_end(r)?,
2091 impl_writeable!(ChannelAnnouncement, {
2094 bitcoin_signature_1,
2095 bitcoin_signature_2,
2099 impl Writeable for UnsignedChannelUpdate {
2100 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2101 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2102 const MESSAGE_FLAGS: u8 = 1;
2103 self.chain_hash.write(w)?;
2104 self.short_channel_id.write(w)?;
2105 self.timestamp.write(w)?;
2106 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2107 all_flags.write(w)?;
2108 self.cltv_expiry_delta.write(w)?;
2109 self.htlc_minimum_msat.write(w)?;
2110 self.fee_base_msat.write(w)?;
2111 self.fee_proportional_millionths.write(w)?;
2112 self.htlc_maximum_msat.write(w)?;
2113 w.write_all(&self.excess_data[..])?;
2118 impl Readable for UnsignedChannelUpdate {
2119 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2121 chain_hash: Readable::read(r)?,
2122 short_channel_id: Readable::read(r)?,
2123 timestamp: Readable::read(r)?,
2125 let flags: u16 = Readable::read(r)?;
2126 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2129 cltv_expiry_delta: Readable::read(r)?,
2130 htlc_minimum_msat: Readable::read(r)?,
2131 fee_base_msat: Readable::read(r)?,
2132 fee_proportional_millionths: Readable::read(r)?,
2133 htlc_maximum_msat: Readable::read(r)?,
2134 excess_data: read_to_end(r)?,
2139 impl_writeable!(ChannelUpdate, {
2144 impl Writeable for ErrorMessage {
2145 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2146 self.channel_id.write(w)?;
2147 (self.data.len() as u16).write(w)?;
2148 w.write_all(self.data.as_bytes())?;
2153 impl Readable for ErrorMessage {
2154 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2156 channel_id: Readable::read(r)?,
2158 let sz: usize = <u16 as Readable>::read(r)? as usize;
2159 let mut data = Vec::with_capacity(sz);
2161 r.read_exact(&mut data)?;
2162 match String::from_utf8(data) {
2164 Err(_) => return Err(DecodeError::InvalidValue),
2171 impl Writeable for WarningMessage {
2172 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2173 self.channel_id.write(w)?;
2174 (self.data.len() as u16).write(w)?;
2175 w.write_all(self.data.as_bytes())?;
2180 impl Readable for WarningMessage {
2181 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2183 channel_id: Readable::read(r)?,
2185 let sz: usize = <u16 as Readable>::read(r)? as usize;
2186 let mut data = Vec::with_capacity(sz);
2188 r.read_exact(&mut data)?;
2189 match String::from_utf8(data) {
2191 Err(_) => return Err(DecodeError::InvalidValue),
2198 impl Writeable for UnsignedNodeAnnouncement {
2199 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2200 self.features.write(w)?;
2201 self.timestamp.write(w)?;
2202 self.node_id.write(w)?;
2203 w.write_all(&self.rgb)?;
2204 self.alias.write(w)?;
2206 let mut addr_len = 0;
2207 for addr in self.addresses.iter() {
2208 addr_len += 1 + addr.len();
2210 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2211 for addr in self.addresses.iter() {
2214 w.write_all(&self.excess_address_data[..])?;
2215 w.write_all(&self.excess_data[..])?;
2220 impl Readable for UnsignedNodeAnnouncement {
2221 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2222 let features: NodeFeatures = Readable::read(r)?;
2223 let timestamp: u32 = Readable::read(r)?;
2224 let node_id: NodeId = Readable::read(r)?;
2225 let mut rgb = [0; 3];
2226 r.read_exact(&mut rgb)?;
2227 let alias: NodeAlias = Readable::read(r)?;
2229 let addr_len: u16 = Readable::read(r)?;
2230 let mut addresses: Vec<NetAddress> = Vec::new();
2231 let mut addr_readpos = 0;
2232 let mut excess = false;
2233 let mut excess_byte = 0;
2235 if addr_len <= addr_readpos { break; }
2236 match Readable::read(r) {
2238 if addr_len < addr_readpos + 1 + addr.len() {
2239 return Err(DecodeError::BadLengthDescriptor);
2241 addr_readpos += (1 + addr.len()) as u16;
2242 addresses.push(addr);
2244 Ok(Err(unknown_descriptor)) => {
2246 excess_byte = unknown_descriptor;
2249 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2250 Err(e) => return Err(e),
2254 let mut excess_data = vec![];
2255 let excess_address_data = if addr_readpos < addr_len {
2256 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2257 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2259 excess_address_data[0] = excess_byte;
2264 excess_data.push(excess_byte);
2268 excess_data.extend(read_to_end(r)?.iter());
2269 Ok(UnsignedNodeAnnouncement {
2276 excess_address_data,
2282 impl_writeable!(NodeAnnouncement, {
2287 impl Readable for QueryShortChannelIds {
2288 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2289 let chain_hash: BlockHash = Readable::read(r)?;
2291 let encoding_len: u16 = Readable::read(r)?;
2292 let encoding_type: u8 = Readable::read(r)?;
2294 // Must be encoding_type=0 uncompressed serialization. We do not
2295 // support encoding_type=1 zlib serialization.
2296 if encoding_type != EncodingType::Uncompressed as u8 {
2297 return Err(DecodeError::UnsupportedCompression);
2300 // We expect the encoding_len to always includes the 1-byte
2301 // encoding_type and that short_channel_ids are 8-bytes each
2302 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2303 return Err(DecodeError::InvalidValue);
2306 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2307 // less the 1-byte encoding_type
2308 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2309 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2310 for _ in 0..short_channel_id_count {
2311 short_channel_ids.push(Readable::read(r)?);
2314 Ok(QueryShortChannelIds {
2321 impl Writeable for QueryShortChannelIds {
2322 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2323 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2324 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2326 self.chain_hash.write(w)?;
2327 encoding_len.write(w)?;
2329 // We only support type=0 uncompressed serialization
2330 (EncodingType::Uncompressed as u8).write(w)?;
2332 for scid in self.short_channel_ids.iter() {
2340 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2345 impl QueryChannelRange {
2346 /// Calculates the overflow safe ending block height for the query.
2348 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2349 pub fn end_blocknum(&self) -> u32 {
2350 match self.first_blocknum.checked_add(self.number_of_blocks) {
2351 Some(block) => block,
2352 None => u32::max_value(),
2357 impl_writeable_msg!(QueryChannelRange, {
2363 impl Readable for ReplyChannelRange {
2364 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2365 let chain_hash: BlockHash = Readable::read(r)?;
2366 let first_blocknum: u32 = Readable::read(r)?;
2367 let number_of_blocks: u32 = Readable::read(r)?;
2368 let sync_complete: bool = Readable::read(r)?;
2370 let encoding_len: u16 = Readable::read(r)?;
2371 let encoding_type: u8 = Readable::read(r)?;
2373 // Must be encoding_type=0 uncompressed serialization. We do not
2374 // support encoding_type=1 zlib serialization.
2375 if encoding_type != EncodingType::Uncompressed as u8 {
2376 return Err(DecodeError::UnsupportedCompression);
2379 // We expect the encoding_len to always includes the 1-byte
2380 // encoding_type and that short_channel_ids are 8-bytes each
2381 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2382 return Err(DecodeError::InvalidValue);
2385 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2386 // less the 1-byte encoding_type
2387 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2388 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2389 for _ in 0..short_channel_id_count {
2390 short_channel_ids.push(Readable::read(r)?);
2393 Ok(ReplyChannelRange {
2403 impl Writeable for ReplyChannelRange {
2404 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2405 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2406 self.chain_hash.write(w)?;
2407 self.first_blocknum.write(w)?;
2408 self.number_of_blocks.write(w)?;
2409 self.sync_complete.write(w)?;
2411 encoding_len.write(w)?;
2412 (EncodingType::Uncompressed as u8).write(w)?;
2413 for scid in self.short_channel_ids.iter() {
2421 impl_writeable_msg!(GossipTimestampFilter, {
2429 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2431 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2432 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2433 use crate::ln::msgs::{self, TransactionU16LenLimited};
2434 use crate::ln::msgs::{FinalOnionHopData, OnionErrorPacket, OnionHopDataFormat};
2435 use crate::routing::gossip::{NodeAlias, NodeId};
2436 use crate::util::ser::{Writeable, Readable, Hostname};
2438 use bitcoin::hashes::hex::FromHex;
2439 use bitcoin::util::address::Address;
2440 use bitcoin::network::constants::Network;
2441 use bitcoin::blockdata::script::Builder;
2442 use bitcoin::blockdata::opcodes;
2443 use bitcoin::hash_types::{Txid, BlockHash};
2445 use bitcoin::secp256k1::{PublicKey,SecretKey};
2446 use bitcoin::secp256k1::{Secp256k1, Message};
2448 use crate::io::{self, Cursor};
2449 use crate::prelude::*;
2450 use core::convert::TryFrom;
2451 use core::str::FromStr;
2453 use crate::chain::transaction::OutPoint;
2456 fn encoding_channel_reestablish() {
2458 let secp_ctx = Secp256k1::new();
2459 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2462 let cr = msgs::ChannelReestablish {
2463 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],
2464 next_local_commitment_number: 3,
2465 next_remote_commitment_number: 4,
2466 your_last_per_commitment_secret: [9;32],
2467 my_current_per_commitment_point: public_key,
2468 next_funding_txid: None,
2471 let encoded_value = cr.encode();
2475 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
2476 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2477 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2478 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
2479 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
2485 fn encoding_channel_reestablish_with_next_funding_txid() {
2487 let secp_ctx = Secp256k1::new();
2488 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2491 let cr = msgs::ChannelReestablish {
2492 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],
2493 next_local_commitment_number: 3,
2494 next_remote_commitment_number: 4,
2495 your_last_per_commitment_secret: [9;32],
2496 my_current_per_commitment_point: public_key,
2497 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2498 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,
2502 let encoded_value = cr.encode();
2506 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
2507 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2508 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2509 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
2510 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
2511 0, // Type (next_funding_txid)
2513 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
2518 macro_rules! get_keys_from {
2519 ($slice: expr, $secp_ctx: expr) => {
2521 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2522 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2528 macro_rules! get_sig_on {
2529 ($privkey: expr, $ctx: expr, $string: expr) => {
2531 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2532 $ctx.sign_ecdsa(&sighash, &$privkey)
2538 fn encoding_announcement_signatures() {
2539 let secp_ctx = Secp256k1::new();
2540 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2541 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2542 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2543 let announcement_signatures = msgs::AnnouncementSignatures {
2544 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],
2545 short_channel_id: 2316138423780173,
2546 node_signature: sig_1,
2547 bitcoin_signature: sig_2,
2550 let encoded_value = announcement_signatures.encode();
2551 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2554 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2555 let secp_ctx = Secp256k1::new();
2556 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2557 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2558 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2559 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2560 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2561 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2562 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2563 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2564 let mut features = ChannelFeatures::empty();
2565 if unknown_features_bits {
2566 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2568 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2570 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2571 short_channel_id: 2316138423780173,
2572 node_id_1: NodeId::from_pubkey(&pubkey_1),
2573 node_id_2: NodeId::from_pubkey(&pubkey_2),
2574 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2575 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2576 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2578 let channel_announcement = msgs::ChannelAnnouncement {
2579 node_signature_1: sig_1,
2580 node_signature_2: sig_2,
2581 bitcoin_signature_1: sig_3,
2582 bitcoin_signature_2: sig_4,
2583 contents: unsigned_channel_announcement,
2585 let encoded_value = channel_announcement.encode();
2586 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2587 if unknown_features_bits {
2588 target_value.append(&mut hex::decode("0002ffff").unwrap());
2590 target_value.append(&mut hex::decode("0000").unwrap());
2592 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2593 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2595 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2597 assert_eq!(encoded_value, target_value);
2601 fn encoding_channel_announcement() {
2602 do_encoding_channel_announcement(true, false);
2603 do_encoding_channel_announcement(false, true);
2604 do_encoding_channel_announcement(false, false);
2605 do_encoding_channel_announcement(true, true);
2608 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) {
2609 let secp_ctx = Secp256k1::new();
2610 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2611 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2612 let features = if unknown_features_bits {
2613 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2615 // Set to some features we may support
2616 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2618 let mut addresses = Vec::new();
2620 addresses.push(msgs::NetAddress::IPv4 {
2621 addr: [255, 254, 253, 252],
2626 addresses.push(msgs::NetAddress::IPv6 {
2627 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2632 addresses.push(msgs::NetAddress::OnionV2(
2633 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2637 addresses.push(msgs::NetAddress::OnionV3 {
2638 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],
2645 addresses.push(msgs::NetAddress::Hostname {
2646 hostname: Hostname::try_from(String::from("host")).unwrap(),
2650 let mut addr_len = 0;
2651 for addr in &addresses {
2652 addr_len += addr.len() + 1;
2654 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2656 timestamp: 20190119,
2657 node_id: NodeId::from_pubkey(&pubkey_1),
2659 alias: NodeAlias([16;32]),
2661 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() },
2662 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() },
2664 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2665 let node_announcement = msgs::NodeAnnouncement {
2667 contents: unsigned_node_announcement,
2669 let encoded_value = node_announcement.encode();
2670 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2671 if unknown_features_bits {
2672 target_value.append(&mut hex::decode("0002ffff").unwrap());
2674 target_value.append(&mut hex::decode("000122").unwrap());
2676 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2677 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2679 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2682 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2685 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2688 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2691 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2693 if excess_address_data {
2694 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2697 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2699 assert_eq!(encoded_value, target_value);
2703 fn encoding_node_announcement() {
2704 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2705 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2706 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2707 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2708 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2709 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2710 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2711 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2712 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2713 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2716 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2717 let secp_ctx = Secp256k1::new();
2718 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2719 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2720 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2721 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2722 short_channel_id: 2316138423780173,
2723 timestamp: 20190119,
2724 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2725 cltv_expiry_delta: 144,
2726 htlc_minimum_msat: 1000000,
2727 htlc_maximum_msat: 131355275467161,
2728 fee_base_msat: 10000,
2729 fee_proportional_millionths: 20,
2730 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2732 let channel_update = msgs::ChannelUpdate {
2734 contents: unsigned_channel_update
2736 let encoded_value = channel_update.encode();
2737 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2738 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2739 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
2740 target_value.append(&mut hex::decode("01").unwrap());
2741 target_value.append(&mut hex::decode("00").unwrap());
2743 let flag = target_value.last_mut().unwrap();
2747 let flag = target_value.last_mut().unwrap();
2748 *flag = *flag | 1 << 1;
2750 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
2751 target_value.append(&mut hex::decode("0000777788889999").unwrap());
2753 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
2755 assert_eq!(encoded_value, target_value);
2759 fn encoding_channel_update() {
2760 do_encoding_channel_update(false, false, false);
2761 do_encoding_channel_update(false, false, true);
2762 do_encoding_channel_update(true, false, false);
2763 do_encoding_channel_update(true, false, true);
2764 do_encoding_channel_update(false, true, false);
2765 do_encoding_channel_update(false, true, true);
2766 do_encoding_channel_update(true, true, false);
2767 do_encoding_channel_update(true, true, true);
2770 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
2771 let secp_ctx = Secp256k1::new();
2772 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2773 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2774 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2775 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2776 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2777 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2778 let open_channel = msgs::OpenChannel {
2779 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2780 temporary_channel_id: [2; 32],
2781 funding_satoshis: 1311768467284833366,
2782 push_msat: 2536655962884945560,
2783 dust_limit_satoshis: 3608586615801332854,
2784 max_htlc_value_in_flight_msat: 8517154655701053848,
2785 channel_reserve_satoshis: 8665828695742877976,
2786 htlc_minimum_msat: 2316138423780173,
2787 feerate_per_kw: 821716,
2788 to_self_delay: 49340,
2789 max_accepted_htlcs: 49340,
2790 funding_pubkey: pubkey_1,
2791 revocation_basepoint: pubkey_2,
2792 payment_point: pubkey_3,
2793 delayed_payment_basepoint: pubkey_4,
2794 htlc_basepoint: pubkey_5,
2795 first_per_commitment_point: pubkey_6,
2796 channel_flags: if random_bit { 1 << 5 } else { 0 },
2797 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2798 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2800 let encoded_value = open_channel.encode();
2801 let mut target_value = Vec::new();
2802 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2803 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2805 target_value.append(&mut hex::decode("20").unwrap());
2807 target_value.append(&mut hex::decode("00").unwrap());
2810 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2813 target_value.append(&mut hex::decode("0100").unwrap());
2815 assert_eq!(encoded_value, target_value);
2819 fn encoding_open_channel() {
2820 do_encoding_open_channel(false, false, false);
2821 do_encoding_open_channel(false, false, true);
2822 do_encoding_open_channel(false, true, false);
2823 do_encoding_open_channel(false, true, true);
2824 do_encoding_open_channel(true, false, false);
2825 do_encoding_open_channel(true, false, true);
2826 do_encoding_open_channel(true, true, false);
2827 do_encoding_open_channel(true, true, true);
2830 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
2831 let secp_ctx = Secp256k1::new();
2832 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2833 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2834 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2835 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2836 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2837 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2838 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2839 let open_channelv2 = msgs::OpenChannelV2 {
2840 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2841 temporary_channel_id: [2; 32],
2842 funding_feerate_sat_per_1000_weight: 821716,
2843 commitment_feerate_sat_per_1000_weight: 821716,
2844 funding_satoshis: 1311768467284833366,
2845 dust_limit_satoshis: 3608586615801332854,
2846 max_htlc_value_in_flight_msat: 8517154655701053848,
2847 htlc_minimum_msat: 2316138423780173,
2848 to_self_delay: 49340,
2849 max_accepted_htlcs: 49340,
2850 locktime: 305419896,
2851 funding_pubkey: pubkey_1,
2852 revocation_basepoint: pubkey_2,
2853 payment_basepoint: pubkey_3,
2854 delayed_payment_basepoint: pubkey_4,
2855 htlc_basepoint: pubkey_5,
2856 first_per_commitment_point: pubkey_6,
2857 second_per_commitment_point: pubkey_7,
2858 channel_flags: if random_bit { 1 << 5 } else { 0 },
2859 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2860 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
2861 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
2863 let encoded_value = open_channelv2.encode();
2864 let mut target_value = Vec::new();
2865 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2866 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
2867 target_value.append(&mut hex::decode("000c89d4").unwrap());
2868 target_value.append(&mut hex::decode("000c89d4").unwrap());
2869 target_value.append(&mut hex::decode("1234567890123456").unwrap());
2870 target_value.append(&mut hex::decode("3214466870114476").unwrap());
2871 target_value.append(&mut hex::decode("7633030896203198").unwrap());
2872 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
2873 target_value.append(&mut hex::decode("c0bc").unwrap());
2874 target_value.append(&mut hex::decode("c0bc").unwrap());
2875 target_value.append(&mut hex::decode("12345678").unwrap());
2876 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
2877 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
2878 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
2879 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2880 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
2881 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
2882 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
2885 target_value.append(&mut hex::decode("20").unwrap());
2887 target_value.append(&mut hex::decode("00").unwrap());
2890 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
2891 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2894 target_value.append(&mut hex::decode("0100").unwrap());
2896 if require_confirmed_inputs {
2897 target_value.append(&mut hex::decode("0200").unwrap());
2899 assert_eq!(encoded_value, target_value);
2903 fn encoding_open_channelv2() {
2904 do_encoding_open_channelv2(false, false, false, false);
2905 do_encoding_open_channelv2(false, false, false, true);
2906 do_encoding_open_channelv2(false, false, true, false);
2907 do_encoding_open_channelv2(false, false, true, true);
2908 do_encoding_open_channelv2(false, true, false, false);
2909 do_encoding_open_channelv2(false, true, false, true);
2910 do_encoding_open_channelv2(false, true, true, false);
2911 do_encoding_open_channelv2(false, true, true, true);
2912 do_encoding_open_channelv2(true, false, false, false);
2913 do_encoding_open_channelv2(true, false, false, true);
2914 do_encoding_open_channelv2(true, false, true, false);
2915 do_encoding_open_channelv2(true, false, true, true);
2916 do_encoding_open_channelv2(true, true, false, false);
2917 do_encoding_open_channelv2(true, true, false, true);
2918 do_encoding_open_channelv2(true, true, true, false);
2919 do_encoding_open_channelv2(true, true, true, true);
2922 fn do_encoding_accept_channel(shutdown: bool) {
2923 let secp_ctx = Secp256k1::new();
2924 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2925 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2926 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2927 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2928 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2929 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2930 let accept_channel = msgs::AcceptChannel {
2931 temporary_channel_id: [2; 32],
2932 dust_limit_satoshis: 1311768467284833366,
2933 max_htlc_value_in_flight_msat: 2536655962884945560,
2934 channel_reserve_satoshis: 3608586615801332854,
2935 htlc_minimum_msat: 2316138423780173,
2936 minimum_depth: 821716,
2937 to_self_delay: 49340,
2938 max_accepted_htlcs: 49340,
2939 funding_pubkey: pubkey_1,
2940 revocation_basepoint: pubkey_2,
2941 payment_point: pubkey_3,
2942 delayed_payment_basepoint: pubkey_4,
2943 htlc_basepoint: pubkey_5,
2944 first_per_commitment_point: pubkey_6,
2945 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2948 next_local_nonce: None,
2950 let encoded_value = accept_channel.encode();
2951 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
2953 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
2955 assert_eq!(encoded_value, target_value);
2959 fn encoding_accept_channel() {
2960 do_encoding_accept_channel(false);
2961 do_encoding_accept_channel(true);
2964 fn do_encoding_accept_channelv2(shutdown: bool) {
2965 let secp_ctx = Secp256k1::new();
2966 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2967 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2968 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2969 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2970 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
2971 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
2972 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
2973 let accept_channelv2 = msgs::AcceptChannelV2 {
2974 temporary_channel_id: [2; 32],
2975 funding_satoshis: 1311768467284833366,
2976 dust_limit_satoshis: 1311768467284833366,
2977 max_htlc_value_in_flight_msat: 2536655962884945560,
2978 htlc_minimum_msat: 2316138423780173,
2979 minimum_depth: 821716,
2980 to_self_delay: 49340,
2981 max_accepted_htlcs: 49340,
2982 funding_pubkey: pubkey_1,
2983 revocation_basepoint: pubkey_2,
2984 payment_basepoint: pubkey_3,
2985 delayed_payment_basepoint: pubkey_4,
2986 htlc_basepoint: pubkey_5,
2987 first_per_commitment_point: pubkey_6,
2988 second_per_commitment_point: pubkey_7,
2989 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
2991 require_confirmed_inputs: None,
2993 let encoded_value = accept_channelv2.encode();
2994 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
2995 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
2996 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
2997 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
2998 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
2999 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3000 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3001 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3002 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3003 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3004 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3005 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3006 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3007 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3008 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3010 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3011 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3013 assert_eq!(encoded_value, target_value);
3017 fn encoding_accept_channelv2() {
3018 do_encoding_accept_channelv2(false);
3019 do_encoding_accept_channelv2(true);
3023 fn encoding_funding_created() {
3024 let secp_ctx = Secp256k1::new();
3025 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3026 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3027 let funding_created = msgs::FundingCreated {
3028 temporary_channel_id: [2; 32],
3029 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3030 funding_output_index: 255,
3033 partial_signature_with_nonce: None,
3035 next_local_nonce: None,
3037 let encoded_value = funding_created.encode();
3038 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3039 assert_eq!(encoded_value, target_value);
3043 fn encoding_funding_signed() {
3044 let secp_ctx = Secp256k1::new();
3045 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3046 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3047 let funding_signed = msgs::FundingSigned {
3048 channel_id: [2; 32],
3051 partial_signature_with_nonce: None,
3053 let encoded_value = funding_signed.encode();
3054 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3055 assert_eq!(encoded_value, target_value);
3059 fn encoding_channel_ready() {
3060 let secp_ctx = Secp256k1::new();
3061 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3062 let channel_ready = msgs::ChannelReady {
3063 channel_id: [2; 32],
3064 next_per_commitment_point: pubkey_1,
3065 short_channel_id_alias: None,
3067 let encoded_value = channel_ready.encode();
3068 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3069 assert_eq!(encoded_value, target_value);
3073 fn encoding_tx_add_input() {
3074 let tx_add_input = msgs::TxAddInput {
3075 channel_id: [2; 32],
3076 serial_id: 4886718345,
3077 prevtx: TransactionU16LenLimited::new(Transaction {
3079 lock_time: PackedLockTime(0),
3081 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3082 script_sig: Script::new(),
3083 sequence: Sequence(0xfffffffd),
3084 witness: Witness::from_vec(vec![
3085 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3086 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3091 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3095 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3099 prevtx_out: 305419896,
3100 sequence: 305419896,
3102 let encoded_value = tx_add_input.encode();
3103 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3104 assert_eq!(encoded_value, target_value);
3108 fn encoding_tx_add_output() {
3109 let tx_add_output = msgs::TxAddOutput {
3110 channel_id: [2; 32],
3111 serial_id: 4886718345,
3113 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3115 let encoded_value = tx_add_output.encode();
3116 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3117 assert_eq!(encoded_value, target_value);
3121 fn encoding_tx_remove_input() {
3122 let tx_remove_input = msgs::TxRemoveInput {
3123 channel_id: [2; 32],
3124 serial_id: 4886718345,
3126 let encoded_value = tx_remove_input.encode();
3127 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3128 assert_eq!(encoded_value, target_value);
3132 fn encoding_tx_remove_output() {
3133 let tx_remove_output = msgs::TxRemoveOutput {
3134 channel_id: [2; 32],
3135 serial_id: 4886718345,
3137 let encoded_value = tx_remove_output.encode();
3138 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3139 assert_eq!(encoded_value, target_value);
3143 fn encoding_tx_complete() {
3144 let tx_complete = msgs::TxComplete {
3145 channel_id: [2; 32],
3147 let encoded_value = tx_complete.encode();
3148 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3149 assert_eq!(encoded_value, target_value);
3153 fn encoding_tx_signatures() {
3154 let tx_signatures = msgs::TxSignatures {
3155 channel_id: [2; 32],
3156 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3158 Witness::from_vec(vec![
3159 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3160 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3161 Witness::from_vec(vec![
3162 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3163 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3166 let encoded_value = tx_signatures.encode();
3167 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3168 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3169 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3171 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3172 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3173 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3174 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3175 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3176 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3178 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3179 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3180 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3181 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3182 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3183 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3184 assert_eq!(encoded_value, target_value);
3187 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3188 let tx_init_rbf = msgs::TxInitRbf {
3189 channel_id: [2; 32],
3190 locktime: 305419896,
3191 feerate_sat_per_1000_weight: 20190119,
3192 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3194 let encoded_value = tx_init_rbf.encode();
3195 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3196 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3197 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3198 if let Some((_, target)) = funding_value_with_hex_target {
3199 target_value.push(0x00); // Type
3200 target_value.push(target.len() as u8 / 2); // Length
3201 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3203 assert_eq!(encoded_value, target_value);
3207 fn encoding_tx_init_rbf() {
3208 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3209 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3210 do_encoding_tx_init_rbf(None);
3213 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3214 let tx_ack_rbf = msgs::TxAckRbf {
3215 channel_id: [2; 32],
3216 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3218 let encoded_value = tx_ack_rbf.encode();
3219 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3220 if let Some((_, target)) = funding_value_with_hex_target {
3221 target_value.push(0x00); // Type
3222 target_value.push(target.len() as u8 / 2); // Length
3223 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3225 assert_eq!(encoded_value, target_value);
3229 fn encoding_tx_ack_rbf() {
3230 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3231 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3232 do_encoding_tx_ack_rbf(None);
3236 fn encoding_tx_abort() {
3237 let tx_abort = msgs::TxAbort {
3238 channel_id: [2; 32],
3239 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3241 let encoded_value = tx_abort.encode();
3242 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3243 assert_eq!(encoded_value, target_value);
3246 fn do_encoding_shutdown(script_type: u8) {
3247 let secp_ctx = Secp256k1::new();
3248 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3249 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3250 let shutdown = msgs::Shutdown {
3251 channel_id: [2; 32],
3253 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3254 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3255 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3256 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3258 let encoded_value = shutdown.encode();
3259 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3260 if script_type == 1 {
3261 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3262 } else if script_type == 2 {
3263 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3264 } else if script_type == 3 {
3265 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3266 } else if script_type == 4 {
3267 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3269 assert_eq!(encoded_value, target_value);
3273 fn encoding_shutdown() {
3274 do_encoding_shutdown(1);
3275 do_encoding_shutdown(2);
3276 do_encoding_shutdown(3);
3277 do_encoding_shutdown(4);
3281 fn encoding_closing_signed() {
3282 let secp_ctx = Secp256k1::new();
3283 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3284 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3285 let closing_signed = msgs::ClosingSigned {
3286 channel_id: [2; 32],
3287 fee_satoshis: 2316138423780173,
3291 let encoded_value = closing_signed.encode();
3292 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3293 assert_eq!(encoded_value, target_value);
3294 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3296 let closing_signed_with_range = msgs::ClosingSigned {
3297 channel_id: [2; 32],
3298 fee_satoshis: 2316138423780173,
3300 fee_range: Some(msgs::ClosingSignedFeeRange {
3301 min_fee_satoshis: 0xdeadbeef,
3302 max_fee_satoshis: 0x1badcafe01234567,
3305 let encoded_value_with_range = closing_signed_with_range.encode();
3306 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3307 assert_eq!(encoded_value_with_range, target_value_with_range);
3308 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3309 closing_signed_with_range);
3313 fn encoding_update_add_htlc() {
3314 let secp_ctx = Secp256k1::new();
3315 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3316 let onion_routing_packet = msgs::OnionPacket {
3318 public_key: Ok(pubkey_1),
3319 hop_data: [1; 20*65],
3322 let update_add_htlc = msgs::UpdateAddHTLC {
3323 channel_id: [2; 32],
3324 htlc_id: 2316138423780173,
3325 amount_msat: 3608586615801332854,
3326 payment_hash: PaymentHash([1; 32]),
3327 cltv_expiry: 821716,
3328 onion_routing_packet
3330 let encoded_value = update_add_htlc.encode();
3331 let target_value = hex::decode("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").unwrap();
3332 assert_eq!(encoded_value, target_value);
3336 fn encoding_update_fulfill_htlc() {
3337 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3338 channel_id: [2; 32],
3339 htlc_id: 2316138423780173,
3340 payment_preimage: PaymentPreimage([1; 32]),
3342 let encoded_value = update_fulfill_htlc.encode();
3343 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3344 assert_eq!(encoded_value, target_value);
3348 fn encoding_update_fail_htlc() {
3349 let reason = OnionErrorPacket {
3350 data: [1; 32].to_vec(),
3352 let update_fail_htlc = msgs::UpdateFailHTLC {
3353 channel_id: [2; 32],
3354 htlc_id: 2316138423780173,
3357 let encoded_value = update_fail_htlc.encode();
3358 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3359 assert_eq!(encoded_value, target_value);
3363 fn encoding_update_fail_malformed_htlc() {
3364 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3365 channel_id: [2; 32],
3366 htlc_id: 2316138423780173,
3367 sha256_of_onion: [1; 32],
3370 let encoded_value = update_fail_malformed_htlc.encode();
3371 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3372 assert_eq!(encoded_value, target_value);
3375 fn do_encoding_commitment_signed(htlcs: bool) {
3376 let secp_ctx = Secp256k1::new();
3377 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3378 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3379 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3380 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3381 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3382 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3383 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3384 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3385 let commitment_signed = msgs::CommitmentSigned {
3386 channel_id: [2; 32],
3388 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3390 partial_signature_with_nonce: None,
3392 let encoded_value = commitment_signed.encode();
3393 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3395 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3397 target_value.append(&mut hex::decode("0000").unwrap());
3399 assert_eq!(encoded_value, target_value);
3403 fn encoding_commitment_signed() {
3404 do_encoding_commitment_signed(true);
3405 do_encoding_commitment_signed(false);
3409 fn encoding_revoke_and_ack() {
3410 let secp_ctx = Secp256k1::new();
3411 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3412 let raa = msgs::RevokeAndACK {
3413 channel_id: [2; 32],
3414 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],
3415 next_per_commitment_point: pubkey_1,
3417 next_local_nonce: None,
3419 let encoded_value = raa.encode();
3420 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3421 assert_eq!(encoded_value, target_value);
3425 fn encoding_update_fee() {
3426 let update_fee = msgs::UpdateFee {
3427 channel_id: [2; 32],
3428 feerate_per_kw: 20190119,
3430 let encoded_value = update_fee.encode();
3431 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3432 assert_eq!(encoded_value, target_value);
3436 fn encoding_init() {
3437 assert_eq!(msgs::Init {
3438 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3439 remote_network_address: None,
3440 }.encode(), hex::decode("00023fff0003ffffff").unwrap());
3441 assert_eq!(msgs::Init {
3442 features: InitFeatures::from_le_bytes(vec![0xFF]),
3443 remote_network_address: None,
3444 }.encode(), hex::decode("0001ff0001ff").unwrap());
3445 assert_eq!(msgs::Init {
3446 features: InitFeatures::from_le_bytes(vec![]),
3447 remote_network_address: None,
3448 }.encode(), hex::decode("00000000").unwrap());
3450 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3451 remote_network_address: Some(msgs::NetAddress::IPv4 {
3452 addr: [127, 0, 0, 1],
3456 let encoded_value = init_msg.encode();
3457 let target_value = hex::decode("000000000307017f00000103e8").unwrap();
3458 assert_eq!(encoded_value, target_value);
3459 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3463 fn encoding_error() {
3464 let error = msgs::ErrorMessage {
3465 channel_id: [2; 32],
3466 data: String::from("rust-lightning"),
3468 let encoded_value = error.encode();
3469 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3470 assert_eq!(encoded_value, target_value);
3474 fn encoding_warning() {
3475 let error = msgs::WarningMessage {
3476 channel_id: [2; 32],
3477 data: String::from("rust-lightning"),
3479 let encoded_value = error.encode();
3480 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3481 assert_eq!(encoded_value, target_value);
3485 fn encoding_ping() {
3486 let ping = msgs::Ping {
3490 let encoded_value = ping.encode();
3491 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3492 assert_eq!(encoded_value, target_value);
3496 fn encoding_pong() {
3497 let pong = msgs::Pong {
3500 let encoded_value = pong.encode();
3501 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3502 assert_eq!(encoded_value, target_value);
3506 fn encoding_nonfinal_onion_hop_data() {
3507 let mut msg = msgs::OnionHopData {
3508 format: OnionHopDataFormat::NonFinalNode {
3509 short_channel_id: 0xdeadbeef1bad1dea,
3511 amt_to_forward: 0x0badf00d01020304,
3512 outgoing_cltv_value: 0xffffffff,
3514 let encoded_value = msg.encode();
3515 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3516 assert_eq!(encoded_value, target_value);
3517 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3518 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = msg.format {
3519 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3520 } else { panic!(); }
3521 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3522 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3526 fn encoding_final_onion_hop_data() {
3527 let mut msg = msgs::OnionHopData {
3528 format: OnionHopDataFormat::FinalNode {
3530 payment_metadata: None,
3531 keysend_preimage: None,
3533 amt_to_forward: 0x0badf00d01020304,
3534 outgoing_cltv_value: 0xffffffff,
3536 let encoded_value = msg.encode();
3537 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3538 assert_eq!(encoded_value, target_value);
3539 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3540 if let OnionHopDataFormat::FinalNode { payment_data: None, .. } = msg.format { } else { panic!(); }
3541 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3542 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3546 fn encoding_final_onion_hop_data_with_secret() {
3547 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3548 let mut msg = msgs::OnionHopData {
3549 format: OnionHopDataFormat::FinalNode {
3550 payment_data: Some(FinalOnionHopData {
3551 payment_secret: expected_payment_secret,
3552 total_msat: 0x1badca1f
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("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3562 assert_eq!(encoded_value, target_value);
3563 msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3564 if let OnionHopDataFormat::FinalNode {
3565 payment_data: Some(FinalOnionHopData {
3567 total_msat: 0x1badca1f
3569 payment_metadata: None,
3570 keysend_preimage: None,
3572 assert_eq!(payment_secret, expected_payment_secret);
3573 } else { panic!(); }
3574 assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
3575 assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
3579 fn query_channel_range_end_blocknum() {
3580 let tests: Vec<(u32, u32, u32)> = vec![
3581 (10000, 1500, 11500),
3582 (0, 0xffffffff, 0xffffffff),
3583 (1, 0xffffffff, 0xffffffff),
3586 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3587 let sut = msgs::QueryChannelRange {
3588 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3592 assert_eq!(sut.end_blocknum(), expected);
3597 fn encoding_query_channel_range() {
3598 let mut query_channel_range = msgs::QueryChannelRange {
3599 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3600 first_blocknum: 100000,
3601 number_of_blocks: 1500,
3603 let encoded_value = query_channel_range.encode();
3604 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3605 assert_eq!(encoded_value, target_value);
3607 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3608 assert_eq!(query_channel_range.first_blocknum, 100000);
3609 assert_eq!(query_channel_range.number_of_blocks, 1500);
3613 fn encoding_reply_channel_range() {
3614 do_encoding_reply_channel_range(0);
3615 do_encoding_reply_channel_range(1);
3618 fn do_encoding_reply_channel_range(encoding_type: u8) {
3619 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3620 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3621 let mut reply_channel_range = msgs::ReplyChannelRange {
3622 chain_hash: expected_chain_hash,
3623 first_blocknum: 756230,
3624 number_of_blocks: 1500,
3625 sync_complete: true,
3626 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3629 if encoding_type == 0 {
3630 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3631 let encoded_value = reply_channel_range.encode();
3632 assert_eq!(encoded_value, target_value);
3634 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3635 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3636 assert_eq!(reply_channel_range.first_blocknum, 756230);
3637 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3638 assert_eq!(reply_channel_range.sync_complete, true);
3639 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3640 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3641 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3643 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3644 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3645 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3650 fn encoding_query_short_channel_ids() {
3651 do_encoding_query_short_channel_ids(0);
3652 do_encoding_query_short_channel_ids(1);
3655 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
3656 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
3657 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3658 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
3659 chain_hash: expected_chain_hash,
3660 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3663 if encoding_type == 0 {
3664 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3665 let encoded_value = query_short_channel_ids.encode();
3666 assert_eq!(encoded_value, target_value);
3668 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3669 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
3670 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
3671 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
3672 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
3674 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3675 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3676 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3681 fn encoding_reply_short_channel_ids_end() {
3682 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3683 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
3684 chain_hash: expected_chain_hash,
3685 full_information: true,
3687 let encoded_value = reply_short_channel_ids_end.encode();
3688 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
3689 assert_eq!(encoded_value, target_value);
3691 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3692 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
3693 assert_eq!(reply_short_channel_ids_end.full_information, true);
3697 fn encoding_gossip_timestamp_filter(){
3698 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3699 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
3700 chain_hash: expected_chain_hash,
3701 first_timestamp: 1590000000,
3702 timestamp_range: 0xffff_ffff,
3704 let encoded_value = gossip_timestamp_filter.encode();
3705 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
3706 assert_eq!(encoded_value, target_value);
3708 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3709 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
3710 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
3711 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
3715 fn decode_onion_hop_data_len_as_bigsize() {
3716 // Tests that we can decode an onion payload that is >253 bytes.
3717 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
3718 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
3721 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
3722 // payload length to be encoded over multiple bytes rather than a single u8.
3723 let big_payload = encode_big_payload().unwrap();
3724 let mut rd = Cursor::new(&big_payload[..]);
3725 <msgs::OnionHopData as Readable>::read(&mut rd).unwrap();
3727 // see above test, needs to be a separate method for use of the serialization macros.
3728 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
3729 use crate::util::ser::HighZeroBytesDroppedBigSize;
3730 let payload = msgs::OnionHopData {
3731 format: OnionHopDataFormat::NonFinalNode {
3732 short_channel_id: 0xdeadbeef1bad1dea,
3734 amt_to_forward: 1000,
3735 outgoing_cltv_value: 0xffffffff,
3737 let mut encoded_payload = Vec::new();
3738 let test_bytes = vec![42u8; 1000];
3739 if let OnionHopDataFormat::NonFinalNode { short_channel_id } = payload.format {
3740 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
3741 (1, test_bytes, vec_type),
3742 (2, HighZeroBytesDroppedBigSize(payload.amt_to_forward), required),
3743 (4, HighZeroBytesDroppedBigSize(payload.outgoing_cltv_value), required),
3744 (6, short_channel_id, required)