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::blockdata::constants::ChainHash;
28 use bitcoin::secp256k1::PublicKey;
29 use bitcoin::secp256k1::ecdsa::Signature;
30 use bitcoin::{secp256k1, Witness};
31 use bitcoin::blockdata::script::Script;
32 use bitcoin::hash_types::Txid;
34 use crate::blinded_path::payment::ReceiveTlvs;
35 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
36 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
37 use crate::ln::onion_utils;
38 use crate::onion_message;
39 use crate::sign::{NodeSigner, Recipient};
41 use crate::prelude::*;
42 #[cfg(feature = "std")]
43 use core::convert::TryFrom;
47 #[cfg(feature = "std")]
48 use core::str::FromStr;
49 #[cfg(feature = "std")]
50 use std::net::SocketAddr;
51 use core::fmt::Display;
52 use crate::io::{self, Cursor, Read};
53 use crate::io_extras::read_to_end;
55 use crate::events::MessageSendEventsProvider;
56 use crate::util::chacha20poly1305rfc::ChaChaPolyReadAdapter;
57 use crate::util::logger;
58 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
59 use crate::util::base32;
61 use crate::routing::gossip::{NodeAlias, NodeId};
63 /// 21 million * 10^8 * 1000
64 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
67 /// A partial signature that also contains the Musig2 nonce its signer used
68 #[derive(Clone, Debug, PartialEq, Eq)]
69 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
71 /// An error in decoding a message or struct.
72 #[derive(Clone, Debug, PartialEq, Eq)]
73 pub enum DecodeError {
74 /// A version byte specified something we don't know how to handle.
76 /// Includes unknown realm byte in an onion hop data packet.
78 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
79 UnknownRequiredFeature,
80 /// Value was invalid.
82 /// For example, a byte which was supposed to be a bool was something other than a 0
83 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
84 /// syntactically incorrect, etc.
86 /// The buffer to be read was too short.
88 /// A length descriptor in the packet didn't describe the later data correctly.
90 /// Error from [`std::io`].
92 /// The message included zlib-compressed values, which we don't support.
93 UnsupportedCompression,
96 /// An [`init`] message to be sent to or received from a peer.
98 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
99 #[derive(Clone, Debug, PartialEq, Eq)]
101 /// The relevant features which the sender supports.
102 pub features: InitFeatures,
103 /// Indicates chains the sender is interested in.
105 /// If there are no common chains, the connection will be closed.
106 pub networks: Option<Vec<ChainHash>>,
107 /// The receipient's network address.
109 /// This adds the option to report a remote IP address back to a connecting peer using the init
110 /// message. A node can decide to use that information to discover a potential update to its
111 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
113 pub remote_network_address: Option<SocketAddress>,
116 /// An [`error`] message to be sent to or received from a peer.
118 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
119 #[derive(Clone, Debug, PartialEq, Eq)]
120 pub struct ErrorMessage {
121 /// The channel ID involved in the error.
123 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
124 /// with the sending peer should be closed.
125 pub channel_id: ChannelId,
126 /// A possibly human-readable error description.
128 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
129 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
130 /// the terminal emulator or the logging subsystem.
134 /// A [`warning`] message to be sent to or received from a peer.
136 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
137 #[derive(Clone, Debug, PartialEq, Eq)]
138 pub struct WarningMessage {
139 /// The channel ID involved in the warning.
141 /// All-0s indicates a warning unrelated to a specific channel.
142 pub channel_id: ChannelId,
143 /// A possibly human-readable warning description.
145 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
146 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
147 /// the terminal emulator or the logging subsystem.
151 /// A [`ping`] message to be sent to or received from a peer.
153 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
154 #[derive(Clone, Debug, PartialEq, Eq)]
156 /// The desired response length.
158 /// The ping packet size.
160 /// This field is not sent on the wire. byteslen zeros are sent.
164 /// A [`pong`] message to be sent to or received from a peer.
166 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
167 #[derive(Clone, Debug, PartialEq, Eq)]
169 /// The pong packet size.
171 /// This field is not sent on the wire. byteslen zeros are sent.
175 /// An [`open_channel`] message to be sent to or received from a peer.
177 /// Used in V1 channel establishment
179 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
180 #[derive(Clone, Debug, PartialEq, Eq)]
181 pub struct OpenChannel {
182 /// The genesis hash of the blockchain where the channel is to be opened
183 pub chain_hash: ChainHash,
184 /// A temporary channel ID, until the funding outpoint is announced
185 pub temporary_channel_id: ChannelId,
186 /// The channel value
187 pub funding_satoshis: u64,
188 /// The amount to push to the counterparty as part of the open, in milli-satoshi
190 /// The threshold below which outputs on transactions broadcast by sender will be omitted
191 pub dust_limit_satoshis: u64,
192 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
193 pub max_htlc_value_in_flight_msat: u64,
194 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
195 pub channel_reserve_satoshis: u64,
196 /// The minimum HTLC size incoming to sender, in milli-satoshi
197 pub htlc_minimum_msat: u64,
198 /// The feerate per 1000-weight of sender generated transactions, until updated by
200 pub feerate_per_kw: u32,
201 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
202 /// they broadcast a commitment transaction
203 pub to_self_delay: u16,
204 /// The maximum number of inbound HTLCs towards sender
205 pub max_accepted_htlcs: u16,
206 /// The sender's key controlling the funding transaction
207 pub funding_pubkey: PublicKey,
208 /// Used to derive a revocation key for transactions broadcast by counterparty
209 pub revocation_basepoint: PublicKey,
210 /// A payment key to sender for transactions broadcast by counterparty
211 pub payment_point: PublicKey,
212 /// Used to derive a payment key to sender for transactions broadcast by sender
213 pub delayed_payment_basepoint: PublicKey,
214 /// Used to derive an HTLC payment key to sender
215 pub htlc_basepoint: PublicKey,
216 /// The first to-be-broadcast-by-sender transaction's per commitment point
217 pub first_per_commitment_point: PublicKey,
218 /// The channel flags to be used
219 pub channel_flags: u8,
220 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
221 pub shutdown_scriptpubkey: Option<Script>,
222 /// The channel type that this channel will represent
224 /// If this is `None`, we derive the channel type from the intersection of our
225 /// feature bits with our counterparty's feature bits from the [`Init`] message.
226 pub channel_type: Option<ChannelTypeFeatures>,
229 /// An open_channel2 message to be sent by or received from the channel initiator.
231 /// Used in V2 channel establishment
233 // TODO(dual_funding): Add spec link for `open_channel2`.
234 #[derive(Clone, Debug, PartialEq, Eq)]
235 pub struct OpenChannelV2 {
236 /// The genesis hash of the blockchain where the channel is to be opened
237 pub chain_hash: ChainHash,
238 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
239 pub temporary_channel_id: ChannelId,
240 /// The feerate for the funding transaction set by the channel initiator
241 pub funding_feerate_sat_per_1000_weight: u32,
242 /// The feerate for the commitment transaction set by the channel initiator
243 pub commitment_feerate_sat_per_1000_weight: u32,
244 /// Part of the channel value contributed by the channel initiator
245 pub funding_satoshis: u64,
246 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
248 pub dust_limit_satoshis: u64,
249 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
250 pub max_htlc_value_in_flight_msat: u64,
251 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
252 pub htlc_minimum_msat: u64,
253 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
254 /// broadcast a commitment transaction
255 pub to_self_delay: u16,
256 /// The maximum number of inbound HTLCs towards channel initiator
257 pub max_accepted_htlcs: u16,
258 /// The locktime for the funding transaction
260 /// The channel initiator's key controlling the funding transaction
261 pub funding_pubkey: PublicKey,
262 /// Used to derive a revocation key for transactions broadcast by counterparty
263 pub revocation_basepoint: PublicKey,
264 /// A payment key to channel initiator for transactions broadcast by counterparty
265 pub payment_basepoint: PublicKey,
266 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
268 pub delayed_payment_basepoint: PublicKey,
269 /// Used to derive an HTLC payment key to channel initiator
270 pub htlc_basepoint: PublicKey,
271 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
272 pub first_per_commitment_point: PublicKey,
273 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
274 pub second_per_commitment_point: PublicKey,
276 pub channel_flags: u8,
277 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
278 /// collaboratively close
279 pub shutdown_scriptpubkey: Option<Script>,
280 /// The channel type that this channel will represent. If none is set, we derive the channel
281 /// type from the intersection of our feature bits with our counterparty's feature bits from
282 /// the Init message.
283 pub channel_type: Option<ChannelTypeFeatures>,
284 /// Optionally, a requirement that only confirmed inputs can be added
285 pub require_confirmed_inputs: Option<()>,
288 /// An [`accept_channel`] message to be sent to or received from a peer.
290 /// Used in V1 channel establishment
292 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
293 #[derive(Clone, Debug, PartialEq, Eq)]
294 pub struct AcceptChannel {
295 /// A temporary channel ID, until the funding outpoint is announced
296 pub temporary_channel_id: ChannelId,
297 /// The threshold below which outputs on transactions broadcast by sender will be omitted
298 pub dust_limit_satoshis: u64,
299 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
300 pub max_htlc_value_in_flight_msat: u64,
301 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
302 pub channel_reserve_satoshis: u64,
303 /// The minimum HTLC size incoming to sender, in milli-satoshi
304 pub htlc_minimum_msat: u64,
305 /// Minimum depth of the funding transaction before the channel is considered open
306 pub minimum_depth: u32,
307 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
308 pub to_self_delay: u16,
309 /// The maximum number of inbound HTLCs towards sender
310 pub max_accepted_htlcs: u16,
311 /// The sender's key controlling the funding transaction
312 pub funding_pubkey: PublicKey,
313 /// Used to derive a revocation key for transactions broadcast by counterparty
314 pub revocation_basepoint: PublicKey,
315 /// A payment key to sender for transactions broadcast by counterparty
316 pub payment_point: PublicKey,
317 /// Used to derive a payment key to sender for transactions broadcast by sender
318 pub delayed_payment_basepoint: PublicKey,
319 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
320 pub htlc_basepoint: PublicKey,
321 /// The first to-be-broadcast-by-sender transaction's per commitment point
322 pub first_per_commitment_point: PublicKey,
323 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
324 pub shutdown_scriptpubkey: Option<Script>,
325 /// The channel type that this channel will represent.
327 /// If this is `None`, we derive the channel type from the intersection of
328 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
329 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
330 pub channel_type: Option<ChannelTypeFeatures>,
332 /// Next nonce the channel initiator should use to create a funding output signature against
333 pub next_local_nonce: Option<musig2::types::PublicNonce>,
336 /// An accept_channel2 message to be sent by or received from the channel accepter.
338 /// Used in V2 channel establishment
340 // TODO(dual_funding): Add spec link for `accept_channel2`.
341 #[derive(Clone, Debug, PartialEq, Eq)]
342 pub struct AcceptChannelV2 {
343 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
344 pub temporary_channel_id: ChannelId,
345 /// Part of the channel value contributed by the channel acceptor
346 pub funding_satoshis: u64,
347 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
349 pub dust_limit_satoshis: u64,
350 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
351 pub max_htlc_value_in_flight_msat: u64,
352 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
353 pub htlc_minimum_msat: u64,
354 /// Minimum depth of the funding transaction before the channel is considered open
355 pub minimum_depth: u32,
356 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
357 /// broadcast a commitment transaction
358 pub to_self_delay: u16,
359 /// The maximum number of inbound HTLCs towards channel acceptor
360 pub max_accepted_htlcs: u16,
361 /// The channel acceptor's key controlling the funding transaction
362 pub funding_pubkey: PublicKey,
363 /// Used to derive a revocation key for transactions broadcast by counterparty
364 pub revocation_basepoint: PublicKey,
365 /// A payment key to channel acceptor for transactions broadcast by counterparty
366 pub payment_basepoint: PublicKey,
367 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
369 pub delayed_payment_basepoint: PublicKey,
370 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
371 pub htlc_basepoint: PublicKey,
372 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
373 pub first_per_commitment_point: PublicKey,
374 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
375 pub second_per_commitment_point: PublicKey,
376 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
377 /// collaboratively close
378 pub shutdown_scriptpubkey: Option<Script>,
379 /// The channel type that this channel will represent. If none is set, we derive the channel
380 /// type from the intersection of our feature bits with our counterparty's feature bits from
381 /// the Init message.
383 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
384 pub channel_type: Option<ChannelTypeFeatures>,
385 /// Optionally, a requirement that only confirmed inputs can be added
386 pub require_confirmed_inputs: Option<()>,
389 /// A [`funding_created`] message to be sent to or received from a peer.
391 /// Used in V1 channel establishment
393 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
394 #[derive(Clone, Debug, PartialEq, Eq)]
395 pub struct FundingCreated {
396 /// A temporary channel ID, until the funding is established
397 pub temporary_channel_id: ChannelId,
398 /// The funding transaction ID
399 pub funding_txid: Txid,
400 /// The specific output index funding this channel
401 pub funding_output_index: u16,
402 /// The signature of the channel initiator (funder) on the initial commitment transaction
403 pub signature: Signature,
405 /// The partial signature of the channel initiator (funder)
406 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
408 /// Next nonce the channel acceptor should use to finalize the funding output signature
409 pub next_local_nonce: Option<musig2::types::PublicNonce>
412 /// A [`funding_signed`] message to be sent to or received from a peer.
414 /// Used in V1 channel establishment
416 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
417 #[derive(Clone, Debug, PartialEq, Eq)]
418 pub struct FundingSigned {
420 pub channel_id: ChannelId,
421 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
422 pub signature: Signature,
424 /// The partial signature of the channel acceptor (fundee)
425 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
428 /// A [`channel_ready`] message to be sent to or received from a peer.
430 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
431 #[derive(Clone, Debug, PartialEq, Eq)]
432 pub struct ChannelReady {
434 pub channel_id: ChannelId,
435 /// The per-commitment point of the second commitment transaction
436 pub next_per_commitment_point: PublicKey,
437 /// If set, provides a `short_channel_id` alias for this channel.
439 /// The sender will accept payments to be forwarded over this SCID and forward them to this
440 /// messages' recipient.
441 pub short_channel_id_alias: Option<u64>,
444 /// A tx_add_input message for adding an input during interactive transaction construction
446 // TODO(dual_funding): Add spec link for `tx_add_input`.
447 #[derive(Clone, Debug, PartialEq, Eq)]
448 pub struct TxAddInput {
450 pub channel_id: ChannelId,
451 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
454 /// Serialized transaction that contains the output this input spends to verify that it is non
456 pub prevtx: TransactionU16LenLimited,
457 /// The index of the output being spent
459 /// The sequence number of this input
463 /// A tx_add_output message for adding an output during interactive transaction construction.
465 // TODO(dual_funding): Add spec link for `tx_add_output`.
466 #[derive(Clone, Debug, PartialEq, Eq)]
467 pub struct TxAddOutput {
469 pub channel_id: ChannelId,
470 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
473 /// The satoshi value of the output
475 /// The scriptPubKey for the output
479 /// A tx_remove_input message for removing an input during interactive transaction construction.
481 // TODO(dual_funding): Add spec link for `tx_remove_input`.
482 #[derive(Clone, Debug, PartialEq, Eq)]
483 pub struct TxRemoveInput {
485 pub channel_id: ChannelId,
486 /// The serial ID of the input to be removed
490 /// A tx_remove_output message for removing an output during interactive transaction construction.
492 // TODO(dual_funding): Add spec link for `tx_remove_output`.
493 #[derive(Clone, Debug, PartialEq, Eq)]
494 pub struct TxRemoveOutput {
496 pub channel_id: ChannelId,
497 /// The serial ID of the output to be removed
501 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
502 /// interactive transaction construction.
504 // TODO(dual_funding): Add spec link for `tx_complete`.
505 #[derive(Clone, Debug, PartialEq, Eq)]
506 pub struct TxComplete {
508 pub channel_id: ChannelId,
511 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
512 /// interactive transaction construction.
514 // TODO(dual_funding): Add spec link for `tx_signatures`.
515 #[derive(Clone, Debug, PartialEq, Eq)]
516 pub struct TxSignatures {
518 pub channel_id: ChannelId,
521 /// The list of witnesses
522 pub witnesses: Vec<Witness>,
525 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
528 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
529 #[derive(Clone, Debug, PartialEq, Eq)]
530 pub struct TxInitRbf {
532 pub channel_id: ChannelId,
533 /// The locktime of the transaction
535 /// The feerate of the transaction
536 pub feerate_sat_per_1000_weight: u32,
537 /// The number of satoshis the sender will contribute to or, if negative, remove from
538 /// (e.g. splice-out) the funding output of the transaction
539 pub funding_output_contribution: Option<i64>,
542 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
545 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
546 #[derive(Clone, Debug, PartialEq, Eq)]
547 pub struct TxAckRbf {
549 pub channel_id: ChannelId,
550 /// The number of satoshis the sender will contribute to or, if negative, remove from
551 /// (e.g. splice-out) the funding output of the transaction
552 pub funding_output_contribution: Option<i64>,
555 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
557 // TODO(dual_funding): Add spec link for `tx_abort`.
558 #[derive(Clone, Debug, PartialEq, Eq)]
561 pub channel_id: ChannelId,
566 /// A [`shutdown`] message to be sent to or received from a peer.
568 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
569 #[derive(Clone, Debug, PartialEq, Eq)]
570 pub struct Shutdown {
572 pub channel_id: ChannelId,
573 /// The destination of this peer's funds on closing.
575 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
576 pub scriptpubkey: Script,
579 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
581 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
583 #[derive(Clone, Debug, PartialEq, Eq)]
584 pub struct ClosingSignedFeeRange {
585 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
587 pub min_fee_satoshis: u64,
588 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
590 pub max_fee_satoshis: u64,
593 /// A [`closing_signed`] message to be sent to or received from a peer.
595 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
596 #[derive(Clone, Debug, PartialEq, Eq)]
597 pub struct ClosingSigned {
599 pub channel_id: ChannelId,
600 /// The proposed total fee for the closing transaction
601 pub fee_satoshis: u64,
602 /// A signature on the closing transaction
603 pub signature: Signature,
604 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
606 pub fee_range: Option<ClosingSignedFeeRange>,
609 /// An [`update_add_htlc`] message to be sent to or received from a peer.
611 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
612 #[derive(Clone, Debug, PartialEq, Eq)]
613 pub struct UpdateAddHTLC {
615 pub channel_id: ChannelId,
618 /// The HTLC value in milli-satoshi
619 pub amount_msat: u64,
620 /// The payment hash, the pre-image of which controls HTLC redemption
621 pub payment_hash: PaymentHash,
622 /// The expiry height of the HTLC
623 pub cltv_expiry: u32,
624 /// The extra fee skimmed by the sender of this message. See
625 /// [`ChannelConfig::accept_underpaying_htlcs`].
627 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
628 pub skimmed_fee_msat: Option<u64>,
629 pub(crate) onion_routing_packet: OnionPacket,
632 /// An onion message to be sent to or received from a peer.
634 // TODO: update with link to OM when they are merged into the BOLTs
635 #[derive(Clone, Debug, PartialEq, Eq)]
636 pub struct OnionMessage {
637 /// Used in decrypting the onion packet's payload.
638 pub blinding_point: PublicKey,
639 /// The full onion packet including hop data, pubkey, and hmac
640 pub onion_routing_packet: onion_message::Packet,
643 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
645 /// [`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
646 #[derive(Clone, Debug, PartialEq, Eq)]
647 pub struct UpdateFulfillHTLC {
649 pub channel_id: ChannelId,
652 /// The pre-image of the payment hash, allowing HTLC redemption
653 pub payment_preimage: PaymentPreimage,
656 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
658 /// [`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
659 #[derive(Clone, Debug, PartialEq, Eq)]
660 pub struct UpdateFailHTLC {
662 pub channel_id: ChannelId,
665 pub(crate) reason: OnionErrorPacket,
668 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
670 /// [`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
671 #[derive(Clone, Debug, PartialEq, Eq)]
672 pub struct UpdateFailMalformedHTLC {
674 pub channel_id: ChannelId,
677 pub(crate) sha256_of_onion: [u8; 32],
679 pub failure_code: u16,
682 /// A [`commitment_signed`] message to be sent to or received from a peer.
684 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
685 #[derive(Clone, Debug, PartialEq, Eq)]
686 pub struct CommitmentSigned {
688 pub channel_id: ChannelId,
689 /// A signature on the commitment transaction
690 pub signature: Signature,
691 /// Signatures on the HTLC transactions
692 pub htlc_signatures: Vec<Signature>,
694 /// The partial Taproot signature on the commitment transaction
695 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
698 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
700 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
701 #[derive(Clone, Debug, PartialEq, Eq)]
702 pub struct RevokeAndACK {
704 pub channel_id: ChannelId,
705 /// The secret corresponding to the per-commitment point
706 pub per_commitment_secret: [u8; 32],
707 /// The next sender-broadcast commitment transaction's per-commitment point
708 pub next_per_commitment_point: PublicKey,
710 /// Musig nonce the recipient should use in their next commitment signature message
711 pub next_local_nonce: Option<musig2::types::PublicNonce>
714 /// An [`update_fee`] message to be sent to or received from a peer
716 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
717 #[derive(Clone, Debug, PartialEq, Eq)]
718 pub struct UpdateFee {
720 pub channel_id: ChannelId,
721 /// Fee rate per 1000-weight of the transaction
722 pub feerate_per_kw: u32,
725 /// A [`channel_reestablish`] message to be sent to or received from a peer.
727 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
728 #[derive(Clone, Debug, PartialEq, Eq)]
729 pub struct ChannelReestablish {
731 pub channel_id: ChannelId,
732 /// The next commitment number for the sender
733 pub next_local_commitment_number: u64,
734 /// The next commitment number for the recipient
735 pub next_remote_commitment_number: u64,
736 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
737 /// belonging to the recipient
738 pub your_last_per_commitment_secret: [u8; 32],
739 /// The sender's per-commitment point for their current commitment transaction
740 pub my_current_per_commitment_point: PublicKey,
741 /// The next funding transaction ID
742 pub next_funding_txid: Option<Txid>,
745 /// An [`announcement_signatures`] message to be sent to or received from a peer.
747 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
748 #[derive(Clone, Debug, PartialEq, Eq)]
749 pub struct AnnouncementSignatures {
751 pub channel_id: ChannelId,
752 /// The short channel ID
753 pub short_channel_id: u64,
754 /// A signature by the node key
755 pub node_signature: Signature,
756 /// A signature by the funding key
757 pub bitcoin_signature: Signature,
760 /// An address which can be used to connect to a remote peer.
761 #[derive(Clone, Debug, PartialEq, Eq)]
762 pub enum SocketAddress {
763 /// An IPv4 address and port on which the peer is listening.
765 /// The 4-byte IPv4 address
767 /// The port on which the node is listening
770 /// An IPv6 address and port on which the peer is listening.
772 /// The 16-byte IPv6 address
774 /// The port on which the node is listening
777 /// An old-style Tor onion address/port on which the peer is listening.
779 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
780 /// addresses. Thus, the details are not parsed here.
782 /// A new-style Tor onion address/port on which the peer is listening.
784 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
785 /// wrap as base32 and append ".onion".
787 /// The ed25519 long-term public key of the peer
788 ed25519_pubkey: [u8; 32],
789 /// The checksum of the pubkey and version, as included in the onion address
791 /// The version byte, as defined by the Tor Onion v3 spec.
793 /// The port on which the node is listening
796 /// A hostname/port on which the peer is listening.
798 /// The hostname on which the node is listening.
800 /// The port on which the node is listening.
805 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
807 pub(crate) fn get_id(&self) -> u8 {
809 &SocketAddress::TcpIpV4 {..} => { 1 },
810 &SocketAddress::TcpIpV6 {..} => { 2 },
811 &SocketAddress::OnionV2(_) => { 3 },
812 &SocketAddress::OnionV3 {..} => { 4 },
813 &SocketAddress::Hostname {..} => { 5 },
817 /// Strict byte-length of address descriptor, 1-byte type not recorded
818 fn len(&self) -> u16 {
820 &SocketAddress::TcpIpV4 { .. } => { 6 },
821 &SocketAddress::TcpIpV6 { .. } => { 18 },
822 &SocketAddress::OnionV2(_) => { 12 },
823 &SocketAddress::OnionV3 { .. } => { 37 },
824 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
825 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
829 /// The maximum length of any address descriptor, not including the 1-byte type.
830 /// This maximum length is reached by a hostname address descriptor:
831 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
832 pub(crate) const MAX_LEN: u16 = 258;
835 impl Writeable for SocketAddress {
836 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
838 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
843 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
848 &SocketAddress::OnionV2(bytes) => {
850 bytes.write(writer)?;
852 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
854 ed25519_pubkey.write(writer)?;
855 checksum.write(writer)?;
856 version.write(writer)?;
859 &SocketAddress::Hostname { ref hostname, ref port } => {
861 hostname.write(writer)?;
869 impl Readable for Result<SocketAddress, u8> {
870 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
871 let byte = <u8 as Readable>::read(reader)?;
874 Ok(Ok(SocketAddress::TcpIpV4 {
875 addr: Readable::read(reader)?,
876 port: Readable::read(reader)?,
880 Ok(Ok(SocketAddress::TcpIpV6 {
881 addr: Readable::read(reader)?,
882 port: Readable::read(reader)?,
885 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
887 Ok(Ok(SocketAddress::OnionV3 {
888 ed25519_pubkey: Readable::read(reader)?,
889 checksum: Readable::read(reader)?,
890 version: Readable::read(reader)?,
891 port: Readable::read(reader)?,
895 Ok(Ok(SocketAddress::Hostname {
896 hostname: Readable::read(reader)?,
897 port: Readable::read(reader)?,
900 _ => return Ok(Err(byte)),
905 impl Readable for SocketAddress {
906 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
907 match Readable::read(reader) {
908 Ok(Ok(res)) => Ok(res),
909 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
915 /// [`SocketAddress`] error variants
916 #[derive(Debug, Eq, PartialEq, Clone)]
917 pub enum SocketAddressParseError {
918 /// Socket address (IPv4/IPv6) parsing error
920 /// Invalid input format
924 /// Invalid onion v3 address
928 impl fmt::Display for SocketAddressParseError {
929 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
931 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
932 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
933 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
934 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
935 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
940 #[cfg(feature = "std")]
941 impl From<std::net::SocketAddrV4> for SocketAddress {
942 fn from(addr: std::net::SocketAddrV4) -> Self {
943 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
947 #[cfg(feature = "std")]
948 impl From<std::net::SocketAddrV6> for SocketAddress {
949 fn from(addr: std::net::SocketAddrV6) -> Self {
950 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
954 #[cfg(feature = "std")]
955 impl From<std::net::SocketAddr> for SocketAddress {
956 fn from(addr: std::net::SocketAddr) -> Self {
958 std::net::SocketAddr::V4(addr) => addr.into(),
959 std::net::SocketAddr::V6(addr) => addr.into(),
964 #[cfg(feature = "std")]
965 impl std::net::ToSocketAddrs for SocketAddress {
966 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
968 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
970 SocketAddress::TcpIpV4 { addr, port } => {
971 let ip_addr = std::net::Ipv4Addr::from(*addr);
972 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
973 Ok(vec![socket_addr].into_iter())
975 SocketAddress::TcpIpV6 { addr, port } => {
976 let ip_addr = std::net::Ipv6Addr::from(*addr);
977 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
978 Ok(vec![socket_addr].into_iter())
980 SocketAddress::Hostname { ref hostname, port } => {
981 (hostname.as_str(), *port).to_socket_addrs()
983 SocketAddress::OnionV2(..) => {
984 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
985 addresses is currently unsupported."))
987 SocketAddress::OnionV3 { .. } => {
988 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
989 addresses is currently unsupported."))
995 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
997 /// The host part must end with ".onion".
998 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
999 if host.ends_with(".onion") {
1000 let domain = &host[..host.len() - ".onion".len()];
1001 if domain.len() != 56 {
1002 return Err(SocketAddressParseError::InvalidOnionV3);
1004 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1005 if onion.len() != 35 {
1006 return Err(SocketAddressParseError::InvalidOnionV3);
1008 let version = onion[0];
1009 let first_checksum_flag = onion[1];
1010 let second_checksum_flag = onion[2];
1011 let mut ed25519_pubkey = [0; 32];
1012 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1013 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1014 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1017 return Err(SocketAddressParseError::InvalidInput);
1021 impl Display for SocketAddress {
1022 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1024 SocketAddress::TcpIpV4{addr, port} => write!(
1025 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1026 SocketAddress::TcpIpV6{addr, port} => write!(
1028 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1029 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7], addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15], port
1031 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1032 SocketAddress::OnionV3 {
1038 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1039 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1040 addr.extend_from_slice(ed25519_pubkey);
1041 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1042 write!(f, "{}.onion:{}", onion, port)?
1044 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1050 #[cfg(feature = "std")]
1051 impl FromStr for SocketAddress {
1052 type Err = SocketAddressParseError;
1054 fn from_str(s: &str) -> Result<Self, Self::Err> {
1055 match std::net::SocketAddr::from_str(s) {
1056 Ok(addr) => Ok(addr.into()),
1058 let trimmed_input = match s.rfind(":") {
1060 None => return Err(SocketAddressParseError::InvalidInput),
1062 let host = &s[..trimmed_input];
1063 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1064 if host.ends_with(".onion") {
1065 return parse_onion_address(host, port);
1067 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1068 return Ok(SocketAddress::Hostname { hostname, port });
1070 return Err(SocketAddressParseError::SocketAddrParse)
1076 /// Represents the set of gossip messages that require a signature from a node's identity key.
1077 pub enum UnsignedGossipMessage<'a> {
1078 /// An unsigned channel announcement.
1079 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1080 /// An unsigned channel update.
1081 ChannelUpdate(&'a UnsignedChannelUpdate),
1082 /// An unsigned node announcement.
1083 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1086 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1087 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1089 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1090 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1091 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1096 /// The unsigned part of a [`node_announcement`] message.
1098 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1099 #[derive(Clone, Debug, PartialEq, Eq)]
1100 pub struct UnsignedNodeAnnouncement {
1101 /// The advertised features
1102 pub features: NodeFeatures,
1103 /// A strictly monotonic announcement counter, with gaps allowed
1105 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1107 pub node_id: NodeId,
1108 /// An RGB color for UI purposes
1110 /// An alias, for UI purposes.
1112 /// This should be sanitized before use. There is no guarantee of uniqueness.
1113 pub alias: NodeAlias,
1114 /// List of addresses on which this node is reachable
1115 pub addresses: Vec<SocketAddress>,
1116 pub(crate) excess_address_data: Vec<u8>,
1117 pub(crate) excess_data: Vec<u8>,
1119 #[derive(Clone, Debug, PartialEq, Eq)]
1120 /// A [`node_announcement`] message to be sent to or received from a peer.
1122 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1123 pub struct NodeAnnouncement {
1124 /// The signature by the node key
1125 pub signature: Signature,
1126 /// The actual content of the announcement
1127 pub contents: UnsignedNodeAnnouncement,
1130 /// The unsigned part of a [`channel_announcement`] message.
1132 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1133 #[derive(Clone, Debug, PartialEq, Eq)]
1134 pub struct UnsignedChannelAnnouncement {
1135 /// The advertised channel features
1136 pub features: ChannelFeatures,
1137 /// The genesis hash of the blockchain where the channel is to be opened
1138 pub chain_hash: ChainHash,
1139 /// The short channel ID
1140 pub short_channel_id: u64,
1141 /// One of the two `node_id`s which are endpoints of this channel
1142 pub node_id_1: NodeId,
1143 /// The other of the two `node_id`s which are endpoints of this channel
1144 pub node_id_2: NodeId,
1145 /// The funding key for the first node
1146 pub bitcoin_key_1: NodeId,
1147 /// The funding key for the second node
1148 pub bitcoin_key_2: NodeId,
1149 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1152 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1153 pub excess_data: Vec<u8>,
1155 /// A [`channel_announcement`] message to be sent to or received from a peer.
1157 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1158 #[derive(Clone, Debug, PartialEq, Eq)]
1159 pub struct ChannelAnnouncement {
1160 /// Authentication of the announcement by the first public node
1161 pub node_signature_1: Signature,
1162 /// Authentication of the announcement by the second public node
1163 pub node_signature_2: Signature,
1164 /// Proof of funding UTXO ownership by the first public node
1165 pub bitcoin_signature_1: Signature,
1166 /// Proof of funding UTXO ownership by the second public node
1167 pub bitcoin_signature_2: Signature,
1168 /// The actual announcement
1169 pub contents: UnsignedChannelAnnouncement,
1172 /// The unsigned part of a [`channel_update`] message.
1174 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1175 #[derive(Clone, Debug, PartialEq, Eq)]
1176 pub struct UnsignedChannelUpdate {
1177 /// The genesis hash of the blockchain where the channel is to be opened
1178 pub chain_hash: ChainHash,
1179 /// The short channel ID
1180 pub short_channel_id: u64,
1181 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1185 /// The number of blocks such that if:
1186 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1187 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1188 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1189 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1190 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1191 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1192 /// constructing the route.
1193 pub cltv_expiry_delta: u16,
1194 /// The minimum HTLC size incoming to sender, in milli-satoshi
1195 pub htlc_minimum_msat: u64,
1196 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1198 /// This used to be optional.
1199 pub htlc_maximum_msat: u64,
1200 /// The base HTLC fee charged by sender, in milli-satoshi
1201 pub fee_base_msat: u32,
1202 /// The amount to fee multiplier, in micro-satoshi
1203 pub fee_proportional_millionths: u32,
1204 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1207 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1208 pub excess_data: Vec<u8>,
1210 /// A [`channel_update`] message to be sent to or received from a peer.
1212 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1213 #[derive(Clone, Debug, PartialEq, Eq)]
1214 pub struct ChannelUpdate {
1215 /// A signature of the channel update
1216 pub signature: Signature,
1217 /// The actual channel update
1218 pub contents: UnsignedChannelUpdate,
1221 /// A [`query_channel_range`] message is used to query a peer for channel
1222 /// UTXOs in a range of blocks. The recipient of a query makes a best
1223 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1226 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1227 #[derive(Clone, Debug, PartialEq, Eq)]
1228 pub struct QueryChannelRange {
1229 /// The genesis hash of the blockchain being queried
1230 pub chain_hash: ChainHash,
1231 /// The height of the first block for the channel UTXOs being queried
1232 pub first_blocknum: u32,
1233 /// The number of blocks to include in the query results
1234 pub number_of_blocks: u32,
1237 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1240 /// Multiple `reply_channel_range` messages can be sent in reply
1241 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1242 /// best effort to respond based on their local network view which may
1243 /// not be a perfect view of the network. The `short_channel_id`s in the
1244 /// reply are encoded. We only support `encoding_type=0` uncompressed
1245 /// serialization and do not support `encoding_type=1` zlib serialization.
1247 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1248 #[derive(Clone, Debug, PartialEq, Eq)]
1249 pub struct ReplyChannelRange {
1250 /// The genesis hash of the blockchain being queried
1251 pub chain_hash: ChainHash,
1252 /// The height of the first block in the range of the reply
1253 pub first_blocknum: u32,
1254 /// The number of blocks included in the range of the reply
1255 pub number_of_blocks: u32,
1256 /// True when this is the final reply for a query
1257 pub sync_complete: bool,
1258 /// The `short_channel_id`s in the channel range
1259 pub short_channel_ids: Vec<u64>,
1262 /// A [`query_short_channel_ids`] message is used to query a peer for
1263 /// routing gossip messages related to one or more `short_channel_id`s.
1265 /// The query recipient will reply with the latest, if available,
1266 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1267 /// it maintains for the requested `short_channel_id`s followed by a
1268 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1269 /// this query are encoded. We only support `encoding_type=0` uncompressed
1270 /// serialization and do not support `encoding_type=1` zlib serialization.
1272 /// [`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
1273 #[derive(Clone, Debug, PartialEq, Eq)]
1274 pub struct QueryShortChannelIds {
1275 /// The genesis hash of the blockchain being queried
1276 pub chain_hash: ChainHash,
1277 /// The short_channel_ids that are being queried
1278 pub short_channel_ids: Vec<u64>,
1281 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1282 /// message. The query recipient makes a best
1283 /// effort to respond based on their local network view which may not be
1284 /// a perfect view of the network.
1286 /// [`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
1287 #[derive(Clone, Debug, PartialEq, Eq)]
1288 pub struct ReplyShortChannelIdsEnd {
1289 /// The genesis hash of the blockchain that was queried
1290 pub chain_hash: ChainHash,
1291 /// Indicates if the query recipient maintains up-to-date channel
1292 /// information for the `chain_hash`
1293 pub full_information: bool,
1296 /// A [`gossip_timestamp_filter`] message is used by a node to request
1297 /// gossip relay for messages in the requested time range when the
1298 /// `gossip_queries` feature has been negotiated.
1300 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1301 #[derive(Clone, Debug, PartialEq, Eq)]
1302 pub struct GossipTimestampFilter {
1303 /// The genesis hash of the blockchain for channel and node information
1304 pub chain_hash: ChainHash,
1305 /// The starting unix timestamp
1306 pub first_timestamp: u32,
1307 /// The range of information in seconds
1308 pub timestamp_range: u32,
1311 /// Encoding type for data compression of collections in gossip queries.
1313 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1314 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1316 Uncompressed = 0x00,
1319 /// Used to put an error message in a [`LightningError`].
1320 #[derive(Clone, Debug, PartialEq)]
1321 pub enum ErrorAction {
1322 /// The peer took some action which made us think they were useless. Disconnect them.
1324 /// An error message which we should make an effort to send before we disconnect.
1325 msg: Option<ErrorMessage>
1327 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1328 DisconnectPeerWithWarning {
1329 /// A warning message which we should make an effort to send before we disconnect.
1330 msg: WarningMessage,
1332 /// The peer did something harmless that we weren't able to process, just log and ignore
1333 // New code should *not* use this. New code must use IgnoreAndLog, below!
1335 /// The peer did something harmless that we weren't able to meaningfully process.
1336 /// If the error is logged, log it at the given level.
1337 IgnoreAndLog(logger::Level),
1338 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1339 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1340 /// our own channel announcements.
1341 IgnoreDuplicateGossip,
1342 /// The peer did something incorrect. Tell them.
1344 /// The message to send.
1347 /// The peer did something incorrect. Tell them without closing any channels.
1348 SendWarningMessage {
1349 /// The message to send.
1350 msg: WarningMessage,
1351 /// The peer may have done something harmless that we weren't able to meaningfully process,
1352 /// though we should still tell them about it.
1353 /// If this event is logged, log it at the given level.
1354 log_level: logger::Level,
1358 /// An Err type for failure to process messages.
1359 #[derive(Clone, Debug)]
1360 pub struct LightningError {
1361 /// A human-readable message describing the error
1363 /// The action which should be taken against the offending peer.
1364 pub action: ErrorAction,
1367 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1368 /// transaction updates if they were pending.
1369 #[derive(Clone, Debug, PartialEq, Eq)]
1370 pub struct CommitmentUpdate {
1371 /// `update_add_htlc` messages which should be sent
1372 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1373 /// `update_fulfill_htlc` messages which should be sent
1374 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1375 /// `update_fail_htlc` messages which should be sent
1376 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1377 /// `update_fail_malformed_htlc` messages which should be sent
1378 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1379 /// An `update_fee` message which should be sent
1380 pub update_fee: Option<UpdateFee>,
1381 /// A `commitment_signed` message which should be sent
1382 pub commitment_signed: CommitmentSigned,
1385 /// A trait to describe an object which can receive channel messages.
1387 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1388 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1389 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1391 /// Handle an incoming `open_channel` message from the given peer.
1392 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1393 /// Handle an incoming `open_channel2` message from the given peer.
1394 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1395 /// Handle an incoming `accept_channel` message from the given peer.
1396 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1397 /// Handle an incoming `accept_channel2` message from the given peer.
1398 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1399 /// Handle an incoming `funding_created` message from the given peer.
1400 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1401 /// Handle an incoming `funding_signed` message from the given peer.
1402 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1403 /// Handle an incoming `channel_ready` message from the given peer.
1404 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1407 /// Handle an incoming `shutdown` message from the given peer.
1408 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1409 /// Handle an incoming `closing_signed` message from the given peer.
1410 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1412 // Interactive channel construction
1413 /// Handle an incoming `tx_add_input message` from the given peer.
1414 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1415 /// Handle an incoming `tx_add_output` message from the given peer.
1416 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1417 /// Handle an incoming `tx_remove_input` message from the given peer.
1418 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1419 /// Handle an incoming `tx_remove_output` message from the given peer.
1420 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1421 /// Handle an incoming `tx_complete message` from the given peer.
1422 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1423 /// Handle an incoming `tx_signatures` message from the given peer.
1424 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1425 /// Handle an incoming `tx_init_rbf` message from the given peer.
1426 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1427 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1428 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1429 /// Handle an incoming `tx_abort message` from the given peer.
1430 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1433 /// Handle an incoming `update_add_htlc` message from the given peer.
1434 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1435 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1436 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1437 /// Handle an incoming `update_fail_htlc` message from the given peer.
1438 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1439 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1440 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1441 /// Handle an incoming `commitment_signed` message from the given peer.
1442 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1443 /// Handle an incoming `revoke_and_ack` message from the given peer.
1444 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1446 /// Handle an incoming `update_fee` message from the given peer.
1447 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1449 // Channel-to-announce:
1450 /// Handle an incoming `announcement_signatures` message from the given peer.
1451 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1453 // Connection loss/reestablish:
1454 /// Indicates a connection to the peer failed/an existing connection was lost.
1455 fn peer_disconnected(&self, their_node_id: &PublicKey);
1457 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1459 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1460 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1461 /// message handlers may still wish to communicate with this peer.
1462 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1463 /// Handle an incoming `channel_reestablish` message from the given peer.
1464 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1466 /// Handle an incoming `channel_update` message from the given peer.
1467 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1470 /// Handle an incoming `error` message from the given peer.
1471 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1473 // Handler information:
1474 /// Gets the node feature flags which this handler itself supports. All available handlers are
1475 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1476 /// which are broadcasted in our [`NodeAnnouncement`] message.
1477 fn provided_node_features(&self) -> NodeFeatures;
1479 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1480 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1481 /// which are sent in our [`Init`] message.
1483 /// Note that this method is called before [`Self::peer_connected`].
1484 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1486 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1488 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1489 /// connecting to peers.
1490 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1493 /// A trait to describe an object which can receive routing messages.
1495 /// # Implementor DoS Warnings
1497 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1498 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1499 /// repeated disk I/O for queries accessing different parts of the network graph.
1500 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1501 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1502 /// `false` or returning an `Err` otherwise.
1503 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1504 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1505 /// or returning an `Err` otherwise.
1506 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1507 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1508 /// `false` or returning an `Err` otherwise.
1509 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1510 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1511 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1512 /// for a single channel.
1513 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1514 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1515 /// the node *after* the provided pubkey and including up to one announcement immediately
1516 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1517 /// If `None` is provided for `starting_point`, we start at the first node.
1518 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1519 /// Called when a connection is established with a peer. This can be used to
1520 /// perform routing table synchronization using a strategy defined by the
1523 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1524 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1525 /// message handlers may still wish to communicate with this peer.
1526 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1527 /// Handles the reply of a query we initiated to learn about channels
1528 /// for a given range of blocks. We can expect to receive one or more
1529 /// replies to a single query.
1530 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1531 /// Handles the reply of a query we initiated asking for routing gossip
1532 /// messages for a list of channels. We should receive this message when
1533 /// a node has completed its best effort to send us the pertaining routing
1534 /// gossip messages.
1535 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1536 /// Handles when a peer asks us to send a list of `short_channel_id`s
1537 /// for the requested range of blocks.
1538 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1539 /// Handles when a peer asks us to send routing gossip messages for a
1540 /// list of `short_channel_id`s.
1541 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1543 // Handler queueing status:
1544 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1545 /// pending some async action. While there is no guarantee of the rate of future messages, the
1546 /// caller should seek to reduce the rate of new gossip messages handled, especially
1547 /// [`ChannelAnnouncement`]s.
1548 fn processing_queue_high(&self) -> bool;
1550 // Handler information:
1551 /// Gets the node feature flags which this handler itself supports. All available handlers are
1552 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1553 /// which are broadcasted in our [`NodeAnnouncement`] message.
1554 fn provided_node_features(&self) -> NodeFeatures;
1555 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1556 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1557 /// which are sent in our [`Init`] message.
1559 /// Note that this method is called before [`Self::peer_connected`].
1560 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1563 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1564 pub trait OnionMessageHandler {
1565 /// Handle an incoming `onion_message` message from the given peer.
1566 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1568 /// Returns the next pending onion message for the peer with the given node id.
1569 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1571 /// Called when a connection is established with a peer. Can be used to track which peers
1572 /// advertise onion message support and are online.
1574 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1575 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1576 /// message handlers may still wish to communicate with this peer.
1577 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1579 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1580 /// drop and refuse to forward onion messages to this peer.
1581 fn peer_disconnected(&self, their_node_id: &PublicKey);
1583 // Handler information:
1584 /// Gets the node feature flags which this handler itself supports. All available handlers are
1585 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1586 /// which are broadcasted in our [`NodeAnnouncement`] message.
1587 fn provided_node_features(&self) -> NodeFeatures;
1589 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1590 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1591 /// which are sent in our [`Init`] message.
1593 /// Note that this method is called before [`Self::peer_connected`].
1594 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1597 mod fuzzy_internal_msgs {
1598 use bitcoin::secp256k1::PublicKey;
1599 use crate::blinded_path::payment::PaymentConstraints;
1600 use crate::prelude::*;
1601 use crate::ln::{PaymentPreimage, PaymentSecret};
1603 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1604 // them from untrusted input):
1606 pub struct FinalOnionHopData {
1607 pub payment_secret: PaymentSecret,
1608 /// The total value, in msat, of the payment as received by the ultimate recipient.
1609 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1610 pub total_msat: u64,
1613 pub enum InboundOnionPayload {
1615 short_channel_id: u64,
1616 /// The value, in msat, of the payment after this hop's fee is deducted.
1617 amt_to_forward: u64,
1618 outgoing_cltv_value: u32,
1621 payment_data: Option<FinalOnionHopData>,
1622 payment_metadata: Option<Vec<u8>>,
1623 keysend_preimage: Option<PaymentPreimage>,
1624 custom_tlvs: Vec<(u64, Vec<u8>)>,
1626 outgoing_cltv_value: u32,
1631 outgoing_cltv_value: u32,
1632 payment_secret: PaymentSecret,
1633 payment_constraints: PaymentConstraints,
1634 intro_node_blinding_point: PublicKey,
1638 pub(crate) enum OutboundOnionPayload {
1640 short_channel_id: u64,
1641 /// The value, in msat, of the payment after this hop's fee is deducted.
1642 amt_to_forward: u64,
1643 outgoing_cltv_value: u32,
1646 payment_data: Option<FinalOnionHopData>,
1647 payment_metadata: Option<Vec<u8>>,
1648 keysend_preimage: Option<PaymentPreimage>,
1649 custom_tlvs: Vec<(u64, Vec<u8>)>,
1651 outgoing_cltv_value: u32,
1654 encrypted_tlvs: Vec<u8>,
1655 intro_node_blinding_point: Option<PublicKey>,
1660 outgoing_cltv_value: u32,
1661 encrypted_tlvs: Vec<u8>,
1662 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1666 pub struct DecodedOnionErrorPacket {
1667 pub(crate) hmac: [u8; 32],
1668 pub(crate) failuremsg: Vec<u8>,
1669 pub(crate) pad: Vec<u8>,
1673 pub use self::fuzzy_internal_msgs::*;
1674 #[cfg(not(fuzzing))]
1675 pub(crate) use self::fuzzy_internal_msgs::*;
1677 /// BOLT 4 onion packet including hop data for the next peer.
1679 pub struct OnionPacket {
1680 /// BOLT 4 version number.
1682 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1683 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1684 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1685 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1687 pub public_key: Result<PublicKey, secp256k1::Error>,
1688 /// 1300 bytes encrypted payload for the next hop.
1689 pub hop_data: [u8; 20*65],
1690 /// HMAC to verify the integrity of hop_data.
1694 impl onion_utils::Packet for OnionPacket {
1695 type Data = onion_utils::FixedSizeOnionPacket;
1696 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1699 public_key: Ok(pubkey),
1700 hop_data: hop_data.0,
1706 impl Eq for OnionPacket { }
1707 impl PartialEq for OnionPacket {
1708 fn eq(&self, other: &OnionPacket) -> bool {
1709 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1710 if i != j { return false; }
1712 self.version == other.version &&
1713 self.public_key == other.public_key &&
1714 self.hmac == other.hmac
1718 impl fmt::Debug for OnionPacket {
1719 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1720 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1724 #[derive(Clone, Debug, PartialEq, Eq)]
1725 pub(crate) struct OnionErrorPacket {
1726 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1727 // (TODO) We limit it in decode to much lower...
1728 pub(crate) data: Vec<u8>,
1731 impl fmt::Display for DecodeError {
1732 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1734 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1735 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1736 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1737 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1738 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1739 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1740 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1745 impl From<io::Error> for DecodeError {
1746 fn from(e: io::Error) -> Self {
1747 if e.kind() == io::ErrorKind::UnexpectedEof {
1748 DecodeError::ShortRead
1750 DecodeError::Io(e.kind())
1755 #[cfg(not(taproot))]
1756 impl_writeable_msg!(AcceptChannel, {
1757 temporary_channel_id,
1758 dust_limit_satoshis,
1759 max_htlc_value_in_flight_msat,
1760 channel_reserve_satoshis,
1766 revocation_basepoint,
1768 delayed_payment_basepoint,
1770 first_per_commitment_point,
1772 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1773 (1, channel_type, option),
1777 impl_writeable_msg!(AcceptChannel, {
1778 temporary_channel_id,
1779 dust_limit_satoshis,
1780 max_htlc_value_in_flight_msat,
1781 channel_reserve_satoshis,
1787 revocation_basepoint,
1789 delayed_payment_basepoint,
1791 first_per_commitment_point,
1793 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1794 (1, channel_type, option),
1795 (4, next_local_nonce, option),
1798 impl_writeable_msg!(AcceptChannelV2, {
1799 temporary_channel_id,
1801 dust_limit_satoshis,
1802 max_htlc_value_in_flight_msat,
1808 revocation_basepoint,
1810 delayed_payment_basepoint,
1812 first_per_commitment_point,
1813 second_per_commitment_point,
1815 (0, shutdown_scriptpubkey, option),
1816 (1, channel_type, option),
1817 (2, require_confirmed_inputs, option),
1820 impl_writeable_msg!(TxAddInput, {
1828 impl_writeable_msg!(TxAddOutput, {
1835 impl_writeable_msg!(TxRemoveInput, {
1840 impl_writeable_msg!(TxRemoveOutput, {
1845 impl_writeable_msg!(TxComplete, {
1849 impl_writeable_msg!(TxSignatures, {
1855 impl_writeable_msg!(TxInitRbf, {
1858 feerate_sat_per_1000_weight,
1860 (0, funding_output_contribution, option),
1863 impl_writeable_msg!(TxAckRbf, {
1866 (0, funding_output_contribution, option),
1869 impl_writeable_msg!(TxAbort, {
1874 impl_writeable_msg!(AnnouncementSignatures, {
1881 impl_writeable_msg!(ChannelReestablish, {
1883 next_local_commitment_number,
1884 next_remote_commitment_number,
1885 your_last_per_commitment_secret,
1886 my_current_per_commitment_point,
1888 (0, next_funding_txid, option),
1891 impl_writeable_msg!(ClosingSigned,
1892 { channel_id, fee_satoshis, signature },
1893 { (1, fee_range, option) }
1896 impl_writeable!(ClosingSignedFeeRange, {
1901 #[cfg(not(taproot))]
1902 impl_writeable_msg!(CommitmentSigned, {
1909 impl_writeable_msg!(CommitmentSigned, {
1914 (2, partial_signature_with_nonce, option)
1917 impl_writeable!(DecodedOnionErrorPacket, {
1923 #[cfg(not(taproot))]
1924 impl_writeable_msg!(FundingCreated, {
1925 temporary_channel_id,
1927 funding_output_index,
1931 impl_writeable_msg!(FundingCreated, {
1932 temporary_channel_id,
1934 funding_output_index,
1937 (2, partial_signature_with_nonce, option),
1938 (4, next_local_nonce, option)
1941 #[cfg(not(taproot))]
1942 impl_writeable_msg!(FundingSigned, {
1948 impl_writeable_msg!(FundingSigned, {
1952 (2, partial_signature_with_nonce, option)
1955 impl_writeable_msg!(ChannelReady, {
1957 next_per_commitment_point,
1959 (1, short_channel_id_alias, option),
1962 impl Writeable for Init {
1963 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1964 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1965 // our relevant feature bits. This keeps us compatible with old nodes.
1966 self.features.write_up_to_13(w)?;
1967 self.features.write(w)?;
1968 encode_tlv_stream!(w, {
1969 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1970 (3, self.remote_network_address, option),
1976 impl Readable for Init {
1977 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1978 let global_features: InitFeatures = Readable::read(r)?;
1979 let features: InitFeatures = Readable::read(r)?;
1980 let mut remote_network_address: Option<SocketAddress> = None;
1981 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1982 decode_tlv_stream!(r, {
1983 (1, networks, option),
1984 (3, remote_network_address, option)
1987 features: features | global_features,
1988 networks: networks.map(|n| n.0),
1989 remote_network_address,
1994 impl_writeable_msg!(OpenChannel, {
1996 temporary_channel_id,
1999 dust_limit_satoshis,
2000 max_htlc_value_in_flight_msat,
2001 channel_reserve_satoshis,
2007 revocation_basepoint,
2009 delayed_payment_basepoint,
2011 first_per_commitment_point,
2014 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
2015 (1, channel_type, option),
2018 impl_writeable_msg!(OpenChannelV2, {
2020 temporary_channel_id,
2021 funding_feerate_sat_per_1000_weight,
2022 commitment_feerate_sat_per_1000_weight,
2024 dust_limit_satoshis,
2025 max_htlc_value_in_flight_msat,
2031 revocation_basepoint,
2033 delayed_payment_basepoint,
2035 first_per_commitment_point,
2036 second_per_commitment_point,
2039 (0, shutdown_scriptpubkey, option),
2040 (1, channel_type, option),
2041 (2, require_confirmed_inputs, option),
2044 #[cfg(not(taproot))]
2045 impl_writeable_msg!(RevokeAndACK, {
2047 per_commitment_secret,
2048 next_per_commitment_point
2052 impl_writeable_msg!(RevokeAndACK, {
2054 per_commitment_secret,
2055 next_per_commitment_point
2057 (4, next_local_nonce, option)
2060 impl_writeable_msg!(Shutdown, {
2065 impl_writeable_msg!(UpdateFailHTLC, {
2071 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2078 impl_writeable_msg!(UpdateFee, {
2083 impl_writeable_msg!(UpdateFulfillHTLC, {
2089 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2090 // serialization format in a way which assumes we know the total serialized length/message end
2092 impl_writeable!(OnionErrorPacket, {
2096 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2097 // serialization format in a way which assumes we know the total serialized length/message end
2099 impl Writeable for OnionPacket {
2100 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2101 self.version.write(w)?;
2102 match self.public_key {
2103 Ok(pubkey) => pubkey.write(w)?,
2104 Err(_) => [0u8;33].write(w)?,
2106 w.write_all(&self.hop_data)?;
2107 self.hmac.write(w)?;
2112 impl Readable for OnionPacket {
2113 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2115 version: Readable::read(r)?,
2117 let mut buf = [0u8;33];
2118 r.read_exact(&mut buf)?;
2119 PublicKey::from_slice(&buf)
2121 hop_data: Readable::read(r)?,
2122 hmac: Readable::read(r)?,
2127 impl_writeable_msg!(UpdateAddHTLC, {
2133 onion_routing_packet,
2135 (65537, skimmed_fee_msat, option)
2138 impl Readable for OnionMessage {
2139 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2140 let blinding_point: PublicKey = Readable::read(r)?;
2141 let len: u16 = Readable::read(r)?;
2142 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2143 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2146 onion_routing_packet,
2151 impl Writeable for OnionMessage {
2152 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2153 self.blinding_point.write(w)?;
2154 let onion_packet_len = self.onion_routing_packet.serialized_length();
2155 (onion_packet_len as u16).write(w)?;
2156 self.onion_routing_packet.write(w)?;
2161 impl Writeable for FinalOnionHopData {
2162 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2163 self.payment_secret.0.write(w)?;
2164 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2168 impl Readable for FinalOnionHopData {
2169 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2170 let secret: [u8; 32] = Readable::read(r)?;
2171 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2172 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2176 impl Writeable for OutboundOnionPayload {
2177 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2179 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2180 _encode_varint_length_prefixed_tlv!(w, {
2181 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2182 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2183 (6, short_channel_id, required)
2187 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2188 outgoing_cltv_value, ref custom_tlvs,
2190 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2191 // to reject any reserved types in the experimental range if new ones are ever
2193 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2194 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2195 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2196 _encode_varint_length_prefixed_tlv!(w, {
2197 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2198 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2199 (8, payment_data, option),
2200 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2201 }, custom_tlvs.iter());
2203 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2204 _encode_varint_length_prefixed_tlv!(w, {
2205 (10, *encrypted_tlvs, required_vec),
2206 (12, intro_node_blinding_point, option)
2209 Self::BlindedReceive {
2210 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2211 intro_node_blinding_point,
2213 _encode_varint_length_prefixed_tlv!(w, {
2214 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2215 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2216 (10, *encrypted_tlvs, required_vec),
2217 (12, intro_node_blinding_point, option),
2218 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2226 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2227 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2229 let mut cltv_value = None;
2230 let mut short_id: Option<u64> = None;
2231 let mut payment_data: Option<FinalOnionHopData> = None;
2232 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2233 let mut intro_node_blinding_point = None;
2234 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2235 let mut total_msat = None;
2236 let mut keysend_preimage: Option<PaymentPreimage> = None;
2237 let mut custom_tlvs = Vec::new();
2239 let tlv_len = BigSize::read(r)?;
2240 let rd = FixedLengthReader::new(r, tlv_len.0);
2241 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2242 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2243 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2244 (6, short_id, option),
2245 (8, payment_data, option),
2246 (10, encrypted_tlvs_opt, option),
2247 (12, intro_node_blinding_point, option),
2248 (16, payment_metadata, option),
2249 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2250 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2251 (5482373484, keysend_preimage, option)
2252 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2253 if msg_type < 1 << 16 { return Ok(false) }
2254 let mut value = Vec::new();
2255 msg_reader.read_to_end(&mut value)?;
2256 custom_tlvs.push((msg_type, value));
2260 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2262 if let Some(blinding_point) = intro_node_blinding_point {
2263 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2264 return Err(DecodeError::InvalidValue)
2266 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2267 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2268 .map_err(|_| DecodeError::InvalidValue)?;
2269 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2270 let mut s = Cursor::new(&enc_tlvs);
2271 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2272 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2273 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2274 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2275 Ok(Self::BlindedReceive {
2276 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2277 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2278 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2280 payment_constraints,
2281 intro_node_blinding_point: blinding_point,
2285 } else if let Some(short_channel_id) = short_id {
2286 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2287 total_msat.is_some()
2288 { return Err(DecodeError::InvalidValue) }
2291 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2292 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2295 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2296 return Err(DecodeError::InvalidValue)
2298 if let Some(data) = &payment_data {
2299 if data.total_msat > MAX_VALUE_MSAT {
2300 return Err(DecodeError::InvalidValue);
2305 payment_metadata: payment_metadata.map(|w| w.0),
2307 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2308 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2315 impl Writeable for Ping {
2316 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2317 self.ponglen.write(w)?;
2318 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2323 impl Readable for Ping {
2324 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2326 ponglen: Readable::read(r)?,
2328 let byteslen = Readable::read(r)?;
2329 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2336 impl Writeable for Pong {
2337 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2338 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2343 impl Readable for Pong {
2344 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2347 let byteslen = Readable::read(r)?;
2348 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2355 impl Writeable for UnsignedChannelAnnouncement {
2356 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2357 self.features.write(w)?;
2358 self.chain_hash.write(w)?;
2359 self.short_channel_id.write(w)?;
2360 self.node_id_1.write(w)?;
2361 self.node_id_2.write(w)?;
2362 self.bitcoin_key_1.write(w)?;
2363 self.bitcoin_key_2.write(w)?;
2364 w.write_all(&self.excess_data[..])?;
2369 impl Readable for UnsignedChannelAnnouncement {
2370 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2372 features: Readable::read(r)?,
2373 chain_hash: Readable::read(r)?,
2374 short_channel_id: Readable::read(r)?,
2375 node_id_1: Readable::read(r)?,
2376 node_id_2: Readable::read(r)?,
2377 bitcoin_key_1: Readable::read(r)?,
2378 bitcoin_key_2: Readable::read(r)?,
2379 excess_data: read_to_end(r)?,
2384 impl_writeable!(ChannelAnnouncement, {
2387 bitcoin_signature_1,
2388 bitcoin_signature_2,
2392 impl Writeable for UnsignedChannelUpdate {
2393 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2394 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2395 const MESSAGE_FLAGS: u8 = 1;
2396 self.chain_hash.write(w)?;
2397 self.short_channel_id.write(w)?;
2398 self.timestamp.write(w)?;
2399 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2400 all_flags.write(w)?;
2401 self.cltv_expiry_delta.write(w)?;
2402 self.htlc_minimum_msat.write(w)?;
2403 self.fee_base_msat.write(w)?;
2404 self.fee_proportional_millionths.write(w)?;
2405 self.htlc_maximum_msat.write(w)?;
2406 w.write_all(&self.excess_data[..])?;
2411 impl Readable for UnsignedChannelUpdate {
2412 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2414 chain_hash: Readable::read(r)?,
2415 short_channel_id: Readable::read(r)?,
2416 timestamp: Readable::read(r)?,
2418 let flags: u16 = Readable::read(r)?;
2419 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2422 cltv_expiry_delta: Readable::read(r)?,
2423 htlc_minimum_msat: Readable::read(r)?,
2424 fee_base_msat: Readable::read(r)?,
2425 fee_proportional_millionths: Readable::read(r)?,
2426 htlc_maximum_msat: Readable::read(r)?,
2427 excess_data: read_to_end(r)?,
2432 impl_writeable!(ChannelUpdate, {
2437 impl Writeable for ErrorMessage {
2438 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2439 self.channel_id.write(w)?;
2440 (self.data.len() as u16).write(w)?;
2441 w.write_all(self.data.as_bytes())?;
2446 impl Readable for ErrorMessage {
2447 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2449 channel_id: Readable::read(r)?,
2451 let sz: usize = <u16 as Readable>::read(r)? as usize;
2452 let mut data = Vec::with_capacity(sz);
2454 r.read_exact(&mut data)?;
2455 match String::from_utf8(data) {
2457 Err(_) => return Err(DecodeError::InvalidValue),
2464 impl Writeable for WarningMessage {
2465 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2466 self.channel_id.write(w)?;
2467 (self.data.len() as u16).write(w)?;
2468 w.write_all(self.data.as_bytes())?;
2473 impl Readable for WarningMessage {
2474 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2476 channel_id: Readable::read(r)?,
2478 let sz: usize = <u16 as Readable>::read(r)? as usize;
2479 let mut data = Vec::with_capacity(sz);
2481 r.read_exact(&mut data)?;
2482 match String::from_utf8(data) {
2484 Err(_) => return Err(DecodeError::InvalidValue),
2491 impl Writeable for UnsignedNodeAnnouncement {
2492 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2493 self.features.write(w)?;
2494 self.timestamp.write(w)?;
2495 self.node_id.write(w)?;
2496 w.write_all(&self.rgb)?;
2497 self.alias.write(w)?;
2499 let mut addr_len = 0;
2500 for addr in self.addresses.iter() {
2501 addr_len += 1 + addr.len();
2503 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2504 for addr in self.addresses.iter() {
2507 w.write_all(&self.excess_address_data[..])?;
2508 w.write_all(&self.excess_data[..])?;
2513 impl Readable for UnsignedNodeAnnouncement {
2514 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2515 let features: NodeFeatures = Readable::read(r)?;
2516 let timestamp: u32 = Readable::read(r)?;
2517 let node_id: NodeId = Readable::read(r)?;
2518 let mut rgb = [0; 3];
2519 r.read_exact(&mut rgb)?;
2520 let alias: NodeAlias = Readable::read(r)?;
2522 let addr_len: u16 = Readable::read(r)?;
2523 let mut addresses: Vec<SocketAddress> = Vec::new();
2524 let mut addr_readpos = 0;
2525 let mut excess = false;
2526 let mut excess_byte = 0;
2528 if addr_len <= addr_readpos { break; }
2529 match Readable::read(r) {
2531 if addr_len < addr_readpos + 1 + addr.len() {
2532 return Err(DecodeError::BadLengthDescriptor);
2534 addr_readpos += (1 + addr.len()) as u16;
2535 addresses.push(addr);
2537 Ok(Err(unknown_descriptor)) => {
2539 excess_byte = unknown_descriptor;
2542 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2543 Err(e) => return Err(e),
2547 let mut excess_data = vec![];
2548 let excess_address_data = if addr_readpos < addr_len {
2549 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2550 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2552 excess_address_data[0] = excess_byte;
2557 excess_data.push(excess_byte);
2561 excess_data.extend(read_to_end(r)?.iter());
2562 Ok(UnsignedNodeAnnouncement {
2569 excess_address_data,
2575 impl_writeable!(NodeAnnouncement, {
2580 impl Readable for QueryShortChannelIds {
2581 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2582 let chain_hash: ChainHash = Readable::read(r)?;
2584 let encoding_len: u16 = Readable::read(r)?;
2585 let encoding_type: u8 = Readable::read(r)?;
2587 // Must be encoding_type=0 uncompressed serialization. We do not
2588 // support encoding_type=1 zlib serialization.
2589 if encoding_type != EncodingType::Uncompressed as u8 {
2590 return Err(DecodeError::UnsupportedCompression);
2593 // We expect the encoding_len to always includes the 1-byte
2594 // encoding_type and that short_channel_ids are 8-bytes each
2595 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2596 return Err(DecodeError::InvalidValue);
2599 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2600 // less the 1-byte encoding_type
2601 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2602 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2603 for _ in 0..short_channel_id_count {
2604 short_channel_ids.push(Readable::read(r)?);
2607 Ok(QueryShortChannelIds {
2614 impl Writeable for QueryShortChannelIds {
2615 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2616 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2617 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2619 self.chain_hash.write(w)?;
2620 encoding_len.write(w)?;
2622 // We only support type=0 uncompressed serialization
2623 (EncodingType::Uncompressed as u8).write(w)?;
2625 for scid in self.short_channel_ids.iter() {
2633 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2638 impl QueryChannelRange {
2639 /// Calculates the overflow safe ending block height for the query.
2641 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2642 pub fn end_blocknum(&self) -> u32 {
2643 match self.first_blocknum.checked_add(self.number_of_blocks) {
2644 Some(block) => block,
2645 None => u32::max_value(),
2650 impl_writeable_msg!(QueryChannelRange, {
2656 impl Readable for ReplyChannelRange {
2657 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2658 let chain_hash: ChainHash = Readable::read(r)?;
2659 let first_blocknum: u32 = Readable::read(r)?;
2660 let number_of_blocks: u32 = Readable::read(r)?;
2661 let sync_complete: bool = Readable::read(r)?;
2663 let encoding_len: u16 = Readable::read(r)?;
2664 let encoding_type: u8 = Readable::read(r)?;
2666 // Must be encoding_type=0 uncompressed serialization. We do not
2667 // support encoding_type=1 zlib serialization.
2668 if encoding_type != EncodingType::Uncompressed as u8 {
2669 return Err(DecodeError::UnsupportedCompression);
2672 // We expect the encoding_len to always includes the 1-byte
2673 // encoding_type and that short_channel_ids are 8-bytes each
2674 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2675 return Err(DecodeError::InvalidValue);
2678 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2679 // less the 1-byte encoding_type
2680 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2681 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2682 for _ in 0..short_channel_id_count {
2683 short_channel_ids.push(Readable::read(r)?);
2686 Ok(ReplyChannelRange {
2696 impl Writeable for ReplyChannelRange {
2697 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2698 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2699 self.chain_hash.write(w)?;
2700 self.first_blocknum.write(w)?;
2701 self.number_of_blocks.write(w)?;
2702 self.sync_complete.write(w)?;
2704 encoding_len.write(w)?;
2705 (EncodingType::Uncompressed as u8).write(w)?;
2706 for scid in self.short_channel_ids.iter() {
2714 impl_writeable_msg!(GossipTimestampFilter, {
2722 use std::convert::TryFrom;
2723 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2725 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2726 use crate::ln::ChannelId;
2727 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2728 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2729 use crate::ln::msgs::SocketAddress;
2730 use crate::routing::gossip::{NodeAlias, NodeId};
2731 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2732 use crate::util::test_utils;
2734 use bitcoin::hashes::hex::FromHex;
2735 use bitcoin::util::address::Address;
2736 use bitcoin::network::constants::Network;
2737 use bitcoin::blockdata::constants::ChainHash;
2738 use bitcoin::blockdata::script::Builder;
2739 use bitcoin::blockdata::opcodes;
2740 use bitcoin::hash_types::Txid;
2742 use bitcoin::secp256k1::{PublicKey,SecretKey};
2743 use bitcoin::secp256k1::{Secp256k1, Message};
2745 use crate::io::{self, Cursor};
2746 use crate::prelude::*;
2747 use core::str::FromStr;
2748 use crate::chain::transaction::OutPoint;
2750 #[cfg(feature = "std")]
2751 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2752 #[cfg(feature = "std")]
2753 use crate::ln::msgs::SocketAddressParseError;
2756 fn encoding_channel_reestablish() {
2758 let secp_ctx = Secp256k1::new();
2759 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2762 let cr = msgs::ChannelReestablish {
2763 channel_id: ChannelId::from_bytes([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]),
2764 next_local_commitment_number: 3,
2765 next_remote_commitment_number: 4,
2766 your_last_per_commitment_secret: [9;32],
2767 my_current_per_commitment_point: public_key,
2768 next_funding_txid: None,
2771 let encoded_value = cr.encode();
2775 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
2776 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2777 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2778 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
2779 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
2785 fn encoding_channel_reestablish_with_next_funding_txid() {
2787 let secp_ctx = Secp256k1::new();
2788 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2791 let cr = msgs::ChannelReestablish {
2792 channel_id: ChannelId::from_bytes([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]),
2793 next_local_commitment_number: 3,
2794 next_remote_commitment_number: 4,
2795 your_last_per_commitment_secret: [9;32],
2796 my_current_per_commitment_point: public_key,
2797 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2798 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,
2802 let encoded_value = cr.encode();
2806 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
2807 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2808 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2809 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
2810 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
2811 0, // Type (next_funding_txid)
2813 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
2818 macro_rules! get_keys_from {
2819 ($slice: expr, $secp_ctx: expr) => {
2821 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2822 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2828 macro_rules! get_sig_on {
2829 ($privkey: expr, $ctx: expr, $string: expr) => {
2831 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2832 $ctx.sign_ecdsa(&sighash, &$privkey)
2838 fn encoding_announcement_signatures() {
2839 let secp_ctx = Secp256k1::new();
2840 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2841 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2842 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2843 let announcement_signatures = msgs::AnnouncementSignatures {
2844 channel_id: ChannelId::from_bytes([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]),
2845 short_channel_id: 2316138423780173,
2846 node_signature: sig_1,
2847 bitcoin_signature: sig_2,
2850 let encoded_value = announcement_signatures.encode();
2851 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2854 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2855 let secp_ctx = Secp256k1::new();
2856 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2857 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2858 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2859 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2860 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2861 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2862 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2863 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2864 let mut features = ChannelFeatures::empty();
2865 if unknown_features_bits {
2866 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2868 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2870 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2871 short_channel_id: 2316138423780173,
2872 node_id_1: NodeId::from_pubkey(&pubkey_1),
2873 node_id_2: NodeId::from_pubkey(&pubkey_2),
2874 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2875 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2876 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2878 let channel_announcement = msgs::ChannelAnnouncement {
2879 node_signature_1: sig_1,
2880 node_signature_2: sig_2,
2881 bitcoin_signature_1: sig_3,
2882 bitcoin_signature_2: sig_4,
2883 contents: unsigned_channel_announcement,
2885 let encoded_value = channel_announcement.encode();
2886 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2887 if unknown_features_bits {
2888 target_value.append(&mut hex::decode("0002ffff").unwrap());
2890 target_value.append(&mut hex::decode("0000").unwrap());
2892 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2893 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2895 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2897 assert_eq!(encoded_value, target_value);
2901 fn encoding_channel_announcement() {
2902 do_encoding_channel_announcement(true, false);
2903 do_encoding_channel_announcement(false, true);
2904 do_encoding_channel_announcement(false, false);
2905 do_encoding_channel_announcement(true, true);
2908 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) {
2909 let secp_ctx = Secp256k1::new();
2910 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2911 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2912 let features = if unknown_features_bits {
2913 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2915 // Set to some features we may support
2916 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2918 let mut addresses = Vec::new();
2920 addresses.push(SocketAddress::TcpIpV4 {
2921 addr: [255, 254, 253, 252],
2926 addresses.push(SocketAddress::TcpIpV6 {
2927 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2932 addresses.push(msgs::SocketAddress::OnionV2(
2933 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2937 addresses.push(msgs::SocketAddress::OnionV3 {
2938 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],
2945 addresses.push(SocketAddress::Hostname {
2946 hostname: Hostname::try_from(String::from("host")).unwrap(),
2950 let mut addr_len = 0;
2951 for addr in &addresses {
2952 addr_len += addr.len() + 1;
2954 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2956 timestamp: 20190119,
2957 node_id: NodeId::from_pubkey(&pubkey_1),
2959 alias: NodeAlias([16;32]),
2961 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() },
2962 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() },
2964 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2965 let node_announcement = msgs::NodeAnnouncement {
2967 contents: unsigned_node_announcement,
2969 let encoded_value = node_announcement.encode();
2970 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2971 if unknown_features_bits {
2972 target_value.append(&mut hex::decode("0002ffff").unwrap());
2974 target_value.append(&mut hex::decode("000122").unwrap());
2976 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2977 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2979 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2982 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2985 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2988 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2991 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2993 if excess_address_data {
2994 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2997 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2999 assert_eq!(encoded_value, target_value);
3003 fn encoding_node_announcement() {
3004 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3005 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3006 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3007 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3008 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3009 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3010 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3011 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3012 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3013 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3016 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3017 let secp_ctx = Secp256k1::new();
3018 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3019 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3020 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3021 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3022 short_channel_id: 2316138423780173,
3023 timestamp: 20190119,
3024 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3025 cltv_expiry_delta: 144,
3026 htlc_minimum_msat: 1000000,
3027 htlc_maximum_msat: 131355275467161,
3028 fee_base_msat: 10000,
3029 fee_proportional_millionths: 20,
3030 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3032 let channel_update = msgs::ChannelUpdate {
3034 contents: unsigned_channel_update
3036 let encoded_value = channel_update.encode();
3037 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3038 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3039 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
3040 target_value.append(&mut hex::decode("01").unwrap());
3041 target_value.append(&mut hex::decode("00").unwrap());
3043 let flag = target_value.last_mut().unwrap();
3047 let flag = target_value.last_mut().unwrap();
3048 *flag = *flag | 1 << 1;
3050 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
3051 target_value.append(&mut hex::decode("0000777788889999").unwrap());
3053 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
3055 assert_eq!(encoded_value, target_value);
3059 fn encoding_channel_update() {
3060 do_encoding_channel_update(false, false, false);
3061 do_encoding_channel_update(false, false, true);
3062 do_encoding_channel_update(true, false, false);
3063 do_encoding_channel_update(true, false, true);
3064 do_encoding_channel_update(false, true, false);
3065 do_encoding_channel_update(false, true, true);
3066 do_encoding_channel_update(true, true, false);
3067 do_encoding_channel_update(true, true, true);
3070 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3071 let secp_ctx = Secp256k1::new();
3072 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3073 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3074 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3075 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3076 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3077 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3078 let open_channel = msgs::OpenChannel {
3079 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3080 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3081 funding_satoshis: 1311768467284833366,
3082 push_msat: 2536655962884945560,
3083 dust_limit_satoshis: 3608586615801332854,
3084 max_htlc_value_in_flight_msat: 8517154655701053848,
3085 channel_reserve_satoshis: 8665828695742877976,
3086 htlc_minimum_msat: 2316138423780173,
3087 feerate_per_kw: 821716,
3088 to_self_delay: 49340,
3089 max_accepted_htlcs: 49340,
3090 funding_pubkey: pubkey_1,
3091 revocation_basepoint: pubkey_2,
3092 payment_point: pubkey_3,
3093 delayed_payment_basepoint: pubkey_4,
3094 htlc_basepoint: pubkey_5,
3095 first_per_commitment_point: pubkey_6,
3096 channel_flags: if random_bit { 1 << 5 } else { 0 },
3097 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3098 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3100 let encoded_value = open_channel.encode();
3101 let mut target_value = Vec::new();
3102 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3103 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3105 target_value.append(&mut hex::decode("20").unwrap());
3107 target_value.append(&mut hex::decode("00").unwrap());
3110 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3113 target_value.append(&mut hex::decode("0100").unwrap());
3115 assert_eq!(encoded_value, target_value);
3119 fn encoding_open_channel() {
3120 do_encoding_open_channel(false, false, false);
3121 do_encoding_open_channel(false, false, true);
3122 do_encoding_open_channel(false, true, false);
3123 do_encoding_open_channel(false, true, true);
3124 do_encoding_open_channel(true, false, false);
3125 do_encoding_open_channel(true, false, true);
3126 do_encoding_open_channel(true, true, false);
3127 do_encoding_open_channel(true, true, true);
3130 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3131 let secp_ctx = Secp256k1::new();
3132 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3133 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3134 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3135 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3136 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3137 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3138 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3139 let open_channelv2 = msgs::OpenChannelV2 {
3140 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3141 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3142 funding_feerate_sat_per_1000_weight: 821716,
3143 commitment_feerate_sat_per_1000_weight: 821716,
3144 funding_satoshis: 1311768467284833366,
3145 dust_limit_satoshis: 3608586615801332854,
3146 max_htlc_value_in_flight_msat: 8517154655701053848,
3147 htlc_minimum_msat: 2316138423780173,
3148 to_self_delay: 49340,
3149 max_accepted_htlcs: 49340,
3150 locktime: 305419896,
3151 funding_pubkey: pubkey_1,
3152 revocation_basepoint: pubkey_2,
3153 payment_basepoint: pubkey_3,
3154 delayed_payment_basepoint: pubkey_4,
3155 htlc_basepoint: pubkey_5,
3156 first_per_commitment_point: pubkey_6,
3157 second_per_commitment_point: pubkey_7,
3158 channel_flags: if random_bit { 1 << 5 } else { 0 },
3159 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3160 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3161 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3163 let encoded_value = open_channelv2.encode();
3164 let mut target_value = Vec::new();
3165 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3166 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3167 target_value.append(&mut hex::decode("000c89d4").unwrap());
3168 target_value.append(&mut hex::decode("000c89d4").unwrap());
3169 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3170 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3171 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3172 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3173 target_value.append(&mut hex::decode("c0bc").unwrap());
3174 target_value.append(&mut hex::decode("c0bc").unwrap());
3175 target_value.append(&mut hex::decode("12345678").unwrap());
3176 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3177 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3178 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3179 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3180 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3181 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3182 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3185 target_value.append(&mut hex::decode("20").unwrap());
3187 target_value.append(&mut hex::decode("00").unwrap());
3190 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3191 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3194 target_value.append(&mut hex::decode("0100").unwrap());
3196 if require_confirmed_inputs {
3197 target_value.append(&mut hex::decode("0200").unwrap());
3199 assert_eq!(encoded_value, target_value);
3203 fn encoding_open_channelv2() {
3204 do_encoding_open_channelv2(false, false, false, false);
3205 do_encoding_open_channelv2(false, false, false, true);
3206 do_encoding_open_channelv2(false, false, true, false);
3207 do_encoding_open_channelv2(false, false, true, true);
3208 do_encoding_open_channelv2(false, true, false, false);
3209 do_encoding_open_channelv2(false, true, false, true);
3210 do_encoding_open_channelv2(false, true, true, false);
3211 do_encoding_open_channelv2(false, true, true, true);
3212 do_encoding_open_channelv2(true, false, false, false);
3213 do_encoding_open_channelv2(true, false, false, true);
3214 do_encoding_open_channelv2(true, false, true, false);
3215 do_encoding_open_channelv2(true, false, true, true);
3216 do_encoding_open_channelv2(true, true, false, false);
3217 do_encoding_open_channelv2(true, true, false, true);
3218 do_encoding_open_channelv2(true, true, true, false);
3219 do_encoding_open_channelv2(true, true, true, true);
3222 fn do_encoding_accept_channel(shutdown: bool) {
3223 let secp_ctx = Secp256k1::new();
3224 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3225 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3226 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3227 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3228 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3229 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3230 let accept_channel = msgs::AcceptChannel {
3231 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3232 dust_limit_satoshis: 1311768467284833366,
3233 max_htlc_value_in_flight_msat: 2536655962884945560,
3234 channel_reserve_satoshis: 3608586615801332854,
3235 htlc_minimum_msat: 2316138423780173,
3236 minimum_depth: 821716,
3237 to_self_delay: 49340,
3238 max_accepted_htlcs: 49340,
3239 funding_pubkey: pubkey_1,
3240 revocation_basepoint: pubkey_2,
3241 payment_point: pubkey_3,
3242 delayed_payment_basepoint: pubkey_4,
3243 htlc_basepoint: pubkey_5,
3244 first_per_commitment_point: pubkey_6,
3245 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3248 next_local_nonce: None,
3250 let encoded_value = accept_channel.encode();
3251 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3253 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3255 assert_eq!(encoded_value, target_value);
3259 fn encoding_accept_channel() {
3260 do_encoding_accept_channel(false);
3261 do_encoding_accept_channel(true);
3264 fn do_encoding_accept_channelv2(shutdown: bool) {
3265 let secp_ctx = Secp256k1::new();
3266 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3267 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3268 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3269 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3270 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3271 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3272 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3273 let accept_channelv2 = msgs::AcceptChannelV2 {
3274 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3275 funding_satoshis: 1311768467284833366,
3276 dust_limit_satoshis: 1311768467284833366,
3277 max_htlc_value_in_flight_msat: 2536655962884945560,
3278 htlc_minimum_msat: 2316138423780173,
3279 minimum_depth: 821716,
3280 to_self_delay: 49340,
3281 max_accepted_htlcs: 49340,
3282 funding_pubkey: pubkey_1,
3283 revocation_basepoint: pubkey_2,
3284 payment_basepoint: pubkey_3,
3285 delayed_payment_basepoint: pubkey_4,
3286 htlc_basepoint: pubkey_5,
3287 first_per_commitment_point: pubkey_6,
3288 second_per_commitment_point: pubkey_7,
3289 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3291 require_confirmed_inputs: None,
3293 let encoded_value = accept_channelv2.encode();
3294 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3295 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3296 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3297 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3298 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3299 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3300 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3301 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3302 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3303 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3304 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3305 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3306 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3307 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3308 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3310 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3311 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3313 assert_eq!(encoded_value, target_value);
3317 fn encoding_accept_channelv2() {
3318 do_encoding_accept_channelv2(false);
3319 do_encoding_accept_channelv2(true);
3323 fn encoding_funding_created() {
3324 let secp_ctx = Secp256k1::new();
3325 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3326 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3327 let funding_created = msgs::FundingCreated {
3328 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3329 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3330 funding_output_index: 255,
3333 partial_signature_with_nonce: None,
3335 next_local_nonce: None,
3337 let encoded_value = funding_created.encode();
3338 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3339 assert_eq!(encoded_value, target_value);
3343 fn encoding_funding_signed() {
3344 let secp_ctx = Secp256k1::new();
3345 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3346 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3347 let funding_signed = msgs::FundingSigned {
3348 channel_id: ChannelId::from_bytes([2; 32]),
3351 partial_signature_with_nonce: None,
3353 let encoded_value = funding_signed.encode();
3354 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3355 assert_eq!(encoded_value, target_value);
3359 fn encoding_channel_ready() {
3360 let secp_ctx = Secp256k1::new();
3361 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3362 let channel_ready = msgs::ChannelReady {
3363 channel_id: ChannelId::from_bytes([2; 32]),
3364 next_per_commitment_point: pubkey_1,
3365 short_channel_id_alias: None,
3367 let encoded_value = channel_ready.encode();
3368 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3369 assert_eq!(encoded_value, target_value);
3373 fn encoding_tx_add_input() {
3374 let tx_add_input = msgs::TxAddInput {
3375 channel_id: ChannelId::from_bytes([2; 32]),
3376 serial_id: 4886718345,
3377 prevtx: TransactionU16LenLimited::new(Transaction {
3379 lock_time: PackedLockTime(0),
3381 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3382 script_sig: Script::new(),
3383 sequence: Sequence(0xfffffffd),
3384 witness: Witness::from_vec(vec![
3385 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3386 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3391 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3395 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3399 prevtx_out: 305419896,
3400 sequence: 305419896,
3402 let encoded_value = tx_add_input.encode();
3403 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3404 assert_eq!(encoded_value, target_value);
3408 fn encoding_tx_add_output() {
3409 let tx_add_output = msgs::TxAddOutput {
3410 channel_id: ChannelId::from_bytes([2; 32]),
3411 serial_id: 4886718345,
3413 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3415 let encoded_value = tx_add_output.encode();
3416 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3417 assert_eq!(encoded_value, target_value);
3421 fn encoding_tx_remove_input() {
3422 let tx_remove_input = msgs::TxRemoveInput {
3423 channel_id: ChannelId::from_bytes([2; 32]),
3424 serial_id: 4886718345,
3426 let encoded_value = tx_remove_input.encode();
3427 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3428 assert_eq!(encoded_value, target_value);
3432 fn encoding_tx_remove_output() {
3433 let tx_remove_output = msgs::TxRemoveOutput {
3434 channel_id: ChannelId::from_bytes([2; 32]),
3435 serial_id: 4886718345,
3437 let encoded_value = tx_remove_output.encode();
3438 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3439 assert_eq!(encoded_value, target_value);
3443 fn encoding_tx_complete() {
3444 let tx_complete = msgs::TxComplete {
3445 channel_id: ChannelId::from_bytes([2; 32]),
3447 let encoded_value = tx_complete.encode();
3448 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3449 assert_eq!(encoded_value, target_value);
3453 fn encoding_tx_signatures() {
3454 let tx_signatures = msgs::TxSignatures {
3455 channel_id: ChannelId::from_bytes([2; 32]),
3456 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3458 Witness::from_vec(vec![
3459 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3460 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3461 Witness::from_vec(vec![
3462 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3463 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3466 let encoded_value = tx_signatures.encode();
3467 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3468 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3469 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3471 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3472 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3473 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3474 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3475 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3476 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3478 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3479 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3480 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3481 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3482 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3483 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3484 assert_eq!(encoded_value, target_value);
3487 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3488 let tx_init_rbf = msgs::TxInitRbf {
3489 channel_id: ChannelId::from_bytes([2; 32]),
3490 locktime: 305419896,
3491 feerate_sat_per_1000_weight: 20190119,
3492 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3494 let encoded_value = tx_init_rbf.encode();
3495 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3496 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3497 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3498 if let Some((_, target)) = funding_value_with_hex_target {
3499 target_value.push(0x00); // Type
3500 target_value.push(target.len() as u8 / 2); // Length
3501 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3503 assert_eq!(encoded_value, target_value);
3507 fn encoding_tx_init_rbf() {
3508 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3509 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3510 do_encoding_tx_init_rbf(None);
3513 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3514 let tx_ack_rbf = msgs::TxAckRbf {
3515 channel_id: ChannelId::from_bytes([2; 32]),
3516 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3518 let encoded_value = tx_ack_rbf.encode();
3519 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3520 if let Some((_, target)) = funding_value_with_hex_target {
3521 target_value.push(0x00); // Type
3522 target_value.push(target.len() as u8 / 2); // Length
3523 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3525 assert_eq!(encoded_value, target_value);
3529 fn encoding_tx_ack_rbf() {
3530 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3531 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3532 do_encoding_tx_ack_rbf(None);
3536 fn encoding_tx_abort() {
3537 let tx_abort = msgs::TxAbort {
3538 channel_id: ChannelId::from_bytes([2; 32]),
3539 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3541 let encoded_value = tx_abort.encode();
3542 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3543 assert_eq!(encoded_value, target_value);
3546 fn do_encoding_shutdown(script_type: u8) {
3547 let secp_ctx = Secp256k1::new();
3548 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3549 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3550 let shutdown = msgs::Shutdown {
3551 channel_id: ChannelId::from_bytes([2; 32]),
3553 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3554 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3555 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3556 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3558 let encoded_value = shutdown.encode();
3559 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3560 if script_type == 1 {
3561 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3562 } else if script_type == 2 {
3563 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3564 } else if script_type == 3 {
3565 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3566 } else if script_type == 4 {
3567 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3569 assert_eq!(encoded_value, target_value);
3573 fn encoding_shutdown() {
3574 do_encoding_shutdown(1);
3575 do_encoding_shutdown(2);
3576 do_encoding_shutdown(3);
3577 do_encoding_shutdown(4);
3581 fn encoding_closing_signed() {
3582 let secp_ctx = Secp256k1::new();
3583 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3584 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3585 let closing_signed = msgs::ClosingSigned {
3586 channel_id: ChannelId::from_bytes([2; 32]),
3587 fee_satoshis: 2316138423780173,
3591 let encoded_value = closing_signed.encode();
3592 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3593 assert_eq!(encoded_value, target_value);
3594 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3596 let closing_signed_with_range = msgs::ClosingSigned {
3597 channel_id: ChannelId::from_bytes([2; 32]),
3598 fee_satoshis: 2316138423780173,
3600 fee_range: Some(msgs::ClosingSignedFeeRange {
3601 min_fee_satoshis: 0xdeadbeef,
3602 max_fee_satoshis: 0x1badcafe01234567,
3605 let encoded_value_with_range = closing_signed_with_range.encode();
3606 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3607 assert_eq!(encoded_value_with_range, target_value_with_range);
3608 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3609 closing_signed_with_range);
3613 fn encoding_update_add_htlc() {
3614 let secp_ctx = Secp256k1::new();
3615 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3616 let onion_routing_packet = msgs::OnionPacket {
3618 public_key: Ok(pubkey_1),
3619 hop_data: [1; 20*65],
3622 let update_add_htlc = msgs::UpdateAddHTLC {
3623 channel_id: ChannelId::from_bytes([2; 32]),
3624 htlc_id: 2316138423780173,
3625 amount_msat: 3608586615801332854,
3626 payment_hash: PaymentHash([1; 32]),
3627 cltv_expiry: 821716,
3628 onion_routing_packet,
3629 skimmed_fee_msat: None,
3631 let encoded_value = update_add_htlc.encode();
3632 let target_value = hex::decode("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").unwrap();
3633 assert_eq!(encoded_value, target_value);
3637 fn encoding_update_fulfill_htlc() {
3638 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3639 channel_id: ChannelId::from_bytes([2; 32]),
3640 htlc_id: 2316138423780173,
3641 payment_preimage: PaymentPreimage([1; 32]),
3643 let encoded_value = update_fulfill_htlc.encode();
3644 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3645 assert_eq!(encoded_value, target_value);
3649 fn encoding_update_fail_htlc() {
3650 let reason = OnionErrorPacket {
3651 data: [1; 32].to_vec(),
3653 let update_fail_htlc = msgs::UpdateFailHTLC {
3654 channel_id: ChannelId::from_bytes([2; 32]),
3655 htlc_id: 2316138423780173,
3658 let encoded_value = update_fail_htlc.encode();
3659 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3660 assert_eq!(encoded_value, target_value);
3664 fn encoding_update_fail_malformed_htlc() {
3665 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3666 channel_id: ChannelId::from_bytes([2; 32]),
3667 htlc_id: 2316138423780173,
3668 sha256_of_onion: [1; 32],
3671 let encoded_value = update_fail_malformed_htlc.encode();
3672 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3673 assert_eq!(encoded_value, target_value);
3676 fn do_encoding_commitment_signed(htlcs: bool) {
3677 let secp_ctx = Secp256k1::new();
3678 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3679 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3680 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3681 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3682 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3683 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3684 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3685 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3686 let commitment_signed = msgs::CommitmentSigned {
3687 channel_id: ChannelId::from_bytes([2; 32]),
3689 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3691 partial_signature_with_nonce: None,
3693 let encoded_value = commitment_signed.encode();
3694 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3696 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3698 target_value.append(&mut hex::decode("0000").unwrap());
3700 assert_eq!(encoded_value, target_value);
3704 fn encoding_commitment_signed() {
3705 do_encoding_commitment_signed(true);
3706 do_encoding_commitment_signed(false);
3710 fn encoding_revoke_and_ack() {
3711 let secp_ctx = Secp256k1::new();
3712 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3713 let raa = msgs::RevokeAndACK {
3714 channel_id: ChannelId::from_bytes([2; 32]),
3715 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],
3716 next_per_commitment_point: pubkey_1,
3718 next_local_nonce: None,
3720 let encoded_value = raa.encode();
3721 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3722 assert_eq!(encoded_value, target_value);
3726 fn encoding_update_fee() {
3727 let update_fee = msgs::UpdateFee {
3728 channel_id: ChannelId::from_bytes([2; 32]),
3729 feerate_per_kw: 20190119,
3731 let encoded_value = update_fee.encode();
3732 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3733 assert_eq!(encoded_value, target_value);
3737 fn encoding_init() {
3738 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3739 assert_eq!(msgs::Init {
3740 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3741 networks: Some(vec![mainnet_hash]),
3742 remote_network_address: None,
3743 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3744 assert_eq!(msgs::Init {
3745 features: InitFeatures::from_le_bytes(vec![0xFF]),
3747 remote_network_address: None,
3748 }.encode(), hex::decode("0001ff0001ff").unwrap());
3749 assert_eq!(msgs::Init {
3750 features: InitFeatures::from_le_bytes(vec![]),
3751 networks: Some(vec![mainnet_hash]),
3752 remote_network_address: None,
3753 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3754 assert_eq!(msgs::Init {
3755 features: InitFeatures::from_le_bytes(vec![]),
3756 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3757 remote_network_address: None,
3758 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3759 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3760 networks: Some(vec![mainnet_hash]),
3761 remote_network_address: Some(SocketAddress::TcpIpV4 {
3762 addr: [127, 0, 0, 1],
3766 let encoded_value = init_msg.encode();
3767 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3768 assert_eq!(encoded_value, target_value);
3769 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3773 fn encoding_error() {
3774 let error = msgs::ErrorMessage {
3775 channel_id: ChannelId::from_bytes([2; 32]),
3776 data: String::from("rust-lightning"),
3778 let encoded_value = error.encode();
3779 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3780 assert_eq!(encoded_value, target_value);
3784 fn encoding_warning() {
3785 let error = msgs::WarningMessage {
3786 channel_id: ChannelId::from_bytes([2; 32]),
3787 data: String::from("rust-lightning"),
3789 let encoded_value = error.encode();
3790 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3791 assert_eq!(encoded_value, target_value);
3795 fn encoding_ping() {
3796 let ping = msgs::Ping {
3800 let encoded_value = ping.encode();
3801 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3802 assert_eq!(encoded_value, target_value);
3806 fn encoding_pong() {
3807 let pong = msgs::Pong {
3810 let encoded_value = pong.encode();
3811 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3812 assert_eq!(encoded_value, target_value);
3816 fn encoding_nonfinal_onion_hop_data() {
3817 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3818 short_channel_id: 0xdeadbeef1bad1dea,
3819 amt_to_forward: 0x0badf00d01020304,
3820 outgoing_cltv_value: 0xffffffff,
3822 let encoded_value = outbound_msg.encode();
3823 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3824 assert_eq!(encoded_value, target_value);
3826 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3827 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3828 if let msgs::InboundOnionPayload::Forward {
3829 short_channel_id, amt_to_forward, outgoing_cltv_value
3831 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3832 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3833 assert_eq!(outgoing_cltv_value, 0xffffffff);
3834 } else { panic!(); }
3838 fn encoding_final_onion_hop_data() {
3839 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3841 payment_metadata: None,
3842 keysend_preimage: None,
3843 amt_msat: 0x0badf00d01020304,
3844 outgoing_cltv_value: 0xffffffff,
3845 custom_tlvs: vec![],
3847 let encoded_value = outbound_msg.encode();
3848 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3849 assert_eq!(encoded_value, target_value);
3851 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3852 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3853 if let msgs::InboundOnionPayload::Receive {
3854 payment_data: None, amt_msat, outgoing_cltv_value, ..
3856 assert_eq!(amt_msat, 0x0badf00d01020304);
3857 assert_eq!(outgoing_cltv_value, 0xffffffff);
3858 } else { panic!(); }
3862 fn encoding_final_onion_hop_data_with_secret() {
3863 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3864 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3865 payment_data: Some(FinalOnionHopData {
3866 payment_secret: expected_payment_secret,
3867 total_msat: 0x1badca1f
3869 payment_metadata: None,
3870 keysend_preimage: None,
3871 amt_msat: 0x0badf00d01020304,
3872 outgoing_cltv_value: 0xffffffff,
3873 custom_tlvs: vec![],
3875 let encoded_value = outbound_msg.encode();
3876 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3877 assert_eq!(encoded_value, target_value);
3879 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3880 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3881 if let msgs::InboundOnionPayload::Receive {
3882 payment_data: Some(FinalOnionHopData {
3884 total_msat: 0x1badca1f
3886 amt_msat, outgoing_cltv_value,
3887 payment_metadata: None,
3888 keysend_preimage: None,
3891 assert_eq!(payment_secret, expected_payment_secret);
3892 assert_eq!(amt_msat, 0x0badf00d01020304);
3893 assert_eq!(outgoing_cltv_value, 0xffffffff);
3894 assert_eq!(custom_tlvs, vec![]);
3895 } else { panic!(); }
3899 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3900 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3902 let bad_type_range_tlvs = vec![
3903 ((1 << 16) - 4, vec![42]),
3904 ((1 << 16) - 2, vec![42; 32]),
3906 let mut msg = msgs::OutboundOnionPayload::Receive {
3908 payment_metadata: None,
3909 keysend_preimage: None,
3910 custom_tlvs: bad_type_range_tlvs,
3911 amt_msat: 0x0badf00d01020304,
3912 outgoing_cltv_value: 0xffffffff,
3914 let encoded_value = msg.encode();
3915 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3916 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
3917 let good_type_range_tlvs = vec![
3918 ((1 << 16) - 3, vec![42]),
3919 ((1 << 16) - 1, vec![42; 32]),
3921 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3922 *custom_tlvs = good_type_range_tlvs.clone();
3924 let encoded_value = msg.encode();
3925 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
3927 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3933 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3934 let expected_custom_tlvs = vec![
3935 (5482373483, vec![0x12, 0x34]),
3936 (5482373487, vec![0x42u8; 8]),
3938 let msg = msgs::OutboundOnionPayload::Receive {
3940 payment_metadata: None,
3941 keysend_preimage: None,
3942 custom_tlvs: expected_custom_tlvs.clone(),
3943 amt_msat: 0x0badf00d01020304,
3944 outgoing_cltv_value: 0xffffffff,
3946 let encoded_value = msg.encode();
3947 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3948 assert_eq!(encoded_value, target_value);
3949 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3950 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3951 if let msgs::InboundOnionPayload::Receive {
3953 payment_metadata: None,
3954 keysend_preimage: None,
3957 outgoing_cltv_value,
3960 assert_eq!(custom_tlvs, expected_custom_tlvs);
3961 assert_eq!(amt_msat, 0x0badf00d01020304);
3962 assert_eq!(outgoing_cltv_value, 0xffffffff);
3963 } else { panic!(); }
3967 fn query_channel_range_end_blocknum() {
3968 let tests: Vec<(u32, u32, u32)> = vec![
3969 (10000, 1500, 11500),
3970 (0, 0xffffffff, 0xffffffff),
3971 (1, 0xffffffff, 0xffffffff),
3974 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3975 let sut = msgs::QueryChannelRange {
3976 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3980 assert_eq!(sut.end_blocknum(), expected);
3985 fn encoding_query_channel_range() {
3986 let mut query_channel_range = msgs::QueryChannelRange {
3987 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3988 first_blocknum: 100000,
3989 number_of_blocks: 1500,
3991 let encoded_value = query_channel_range.encode();
3992 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
3993 assert_eq!(encoded_value, target_value);
3995 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3996 assert_eq!(query_channel_range.first_blocknum, 100000);
3997 assert_eq!(query_channel_range.number_of_blocks, 1500);
4001 fn encoding_reply_channel_range() {
4002 do_encoding_reply_channel_range(0);
4003 do_encoding_reply_channel_range(1);
4006 fn do_encoding_reply_channel_range(encoding_type: u8) {
4007 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4008 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4009 let mut reply_channel_range = msgs::ReplyChannelRange {
4010 chain_hash: expected_chain_hash,
4011 first_blocknum: 756230,
4012 number_of_blocks: 1500,
4013 sync_complete: true,
4014 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4017 if encoding_type == 0 {
4018 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4019 let encoded_value = reply_channel_range.encode();
4020 assert_eq!(encoded_value, target_value);
4022 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4023 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4024 assert_eq!(reply_channel_range.first_blocknum, 756230);
4025 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4026 assert_eq!(reply_channel_range.sync_complete, true);
4027 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4028 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4029 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4031 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4032 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4033 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4038 fn encoding_query_short_channel_ids() {
4039 do_encoding_query_short_channel_ids(0);
4040 do_encoding_query_short_channel_ids(1);
4043 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4044 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4045 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4046 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4047 chain_hash: expected_chain_hash,
4048 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4051 if encoding_type == 0 {
4052 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4053 let encoded_value = query_short_channel_ids.encode();
4054 assert_eq!(encoded_value, target_value);
4056 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4057 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4058 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4059 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4060 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4062 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4063 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4064 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4069 fn encoding_reply_short_channel_ids_end() {
4070 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4071 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4072 chain_hash: expected_chain_hash,
4073 full_information: true,
4075 let encoded_value = reply_short_channel_ids_end.encode();
4076 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4077 assert_eq!(encoded_value, target_value);
4079 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4080 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4081 assert_eq!(reply_short_channel_ids_end.full_information, true);
4085 fn encoding_gossip_timestamp_filter(){
4086 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4087 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4088 chain_hash: expected_chain_hash,
4089 first_timestamp: 1590000000,
4090 timestamp_range: 0xffff_ffff,
4092 let encoded_value = gossip_timestamp_filter.encode();
4093 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4094 assert_eq!(encoded_value, target_value);
4096 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4097 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4098 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4099 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4103 fn decode_onion_hop_data_len_as_bigsize() {
4104 // Tests that we can decode an onion payload that is >253 bytes.
4105 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4106 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4109 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4110 // payload length to be encoded over multiple bytes rather than a single u8.
4111 let big_payload = encode_big_payload().unwrap();
4112 let mut rd = Cursor::new(&big_payload[..]);
4114 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4115 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4116 ::read(&mut rd, &&node_signer).unwrap();
4118 // see above test, needs to be a separate method for use of the serialization macros.
4119 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4120 use crate::util::ser::HighZeroBytesDroppedBigSize;
4121 let payload = msgs::OutboundOnionPayload::Forward {
4122 short_channel_id: 0xdeadbeef1bad1dea,
4123 amt_to_forward: 1000,
4124 outgoing_cltv_value: 0xffffffff,
4126 let mut encoded_payload = Vec::new();
4127 let test_bytes = vec![42u8; 1000];
4128 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4129 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4130 (1, test_bytes, required_vec),
4131 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4132 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4133 (6, short_channel_id, required)
4140 #[cfg(feature = "std")]
4141 fn test_socket_address_from_str() {
4142 let tcpip_v4 = SocketAddress::TcpIpV4 {
4143 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4146 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4147 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4149 let tcpip_v6 = SocketAddress::TcpIpV6 {
4150 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4153 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4154 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4156 let hostname = SocketAddress::Hostname {
4157 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4160 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4161 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4163 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4164 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4165 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4167 let onion_v3 = SocketAddress::OnionV3 {
4168 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4169 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4174 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4175 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4177 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4178 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4179 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4180 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4181 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4182 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4183 assert!("localhost".parse::<SocketAddress>().is_err());
4184 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4185 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4186 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4187 assert!("invalid-address".parse::<SocketAddress>().is_err());
4188 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4192 #[cfg(feature = "std")]
4193 fn test_socket_address_to_socket_addrs() {
4194 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4195 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4196 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4197 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4198 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4199 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4200 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4201 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4202 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4206 port: 1234 }.to_socket_addrs().is_err());