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 crate::io::{self, Cursor, Read};
52 use crate::io_extras::read_to_end;
54 use crate::events::MessageSendEventsProvider;
55 use crate::util::chacha20poly1305rfc::ChaChaPolyReadAdapter;
56 use crate::util::logger;
57 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
58 use crate::util::base32;
60 use crate::routing::gossip::{NodeAlias, NodeId};
62 /// 21 million * 10^8 * 1000
63 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
66 /// A partial signature that also contains the Musig2 nonce its signer used
67 #[derive(Clone, Debug, PartialEq, Eq)]
68 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
70 /// An error in decoding a message or struct.
71 #[derive(Clone, Debug, PartialEq, Eq)]
72 pub enum DecodeError {
73 /// A version byte specified something we don't know how to handle.
75 /// Includes unknown realm byte in an onion hop data packet.
77 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
78 UnknownRequiredFeature,
79 /// Value was invalid.
81 /// For example, a byte which was supposed to be a bool was something other than a 0
82 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
83 /// syntactically incorrect, etc.
85 /// The buffer to be read was too short.
87 /// A length descriptor in the packet didn't describe the later data correctly.
89 /// Error from [`std::io`].
91 /// The message included zlib-compressed values, which we don't support.
92 UnsupportedCompression,
95 /// An [`init`] message to be sent to or received from a peer.
97 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
98 #[derive(Clone, Debug, PartialEq, Eq)]
100 /// The relevant features which the sender supports.
101 pub features: InitFeatures,
102 /// Indicates chains the sender is interested in.
104 /// If there are no common chains, the connection will be closed.
105 pub networks: Option<Vec<ChainHash>>,
106 /// The receipient's network address.
108 /// This adds the option to report a remote IP address back to a connecting peer using the init
109 /// message. A node can decide to use that information to discover a potential update to its
110 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
112 pub remote_network_address: Option<SocketAddress>,
115 /// An [`error`] message to be sent to or received from a peer.
117 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
118 #[derive(Clone, Debug, PartialEq, Eq)]
119 pub struct ErrorMessage {
120 /// The channel ID involved in the error.
122 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
123 /// with the sending peer should be closed.
124 pub channel_id: ChannelId,
125 /// A possibly human-readable error description.
127 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
128 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
129 /// the terminal emulator or the logging subsystem.
133 /// A [`warning`] message to be sent to or received from a peer.
135 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
136 #[derive(Clone, Debug, PartialEq, Eq)]
137 pub struct WarningMessage {
138 /// The channel ID involved in the warning.
140 /// All-0s indicates a warning unrelated to a specific channel.
141 pub channel_id: ChannelId,
142 /// A possibly human-readable warning description.
144 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
145 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
146 /// the terminal emulator or the logging subsystem.
150 /// A [`ping`] message to be sent to or received from a peer.
152 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
153 #[derive(Clone, Debug, PartialEq, Eq)]
155 /// The desired response length.
157 /// The ping packet size.
159 /// This field is not sent on the wire. byteslen zeros are sent.
163 /// A [`pong`] message to be sent to or received from a peer.
165 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
166 #[derive(Clone, Debug, PartialEq, Eq)]
168 /// The pong packet size.
170 /// This field is not sent on the wire. byteslen zeros are sent.
174 /// An [`open_channel`] message to be sent to or received from a peer.
176 /// Used in V1 channel establishment
178 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
179 #[derive(Clone, Debug, PartialEq, Eq)]
180 pub struct OpenChannel {
181 /// The genesis hash of the blockchain where the channel is to be opened
182 pub chain_hash: ChainHash,
183 /// A temporary channel ID, until the funding outpoint is announced
184 pub temporary_channel_id: ChannelId,
185 /// The channel value
186 pub funding_satoshis: u64,
187 /// The amount to push to the counterparty as part of the open, in milli-satoshi
189 /// The threshold below which outputs on transactions broadcast by sender will be omitted
190 pub dust_limit_satoshis: u64,
191 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
192 pub max_htlc_value_in_flight_msat: u64,
193 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
194 pub channel_reserve_satoshis: u64,
195 /// The minimum HTLC size incoming to sender, in milli-satoshi
196 pub htlc_minimum_msat: u64,
197 /// The feerate per 1000-weight of sender generated transactions, until updated by
199 pub feerate_per_kw: u32,
200 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if
201 /// they broadcast a commitment transaction
202 pub to_self_delay: u16,
203 /// The maximum number of inbound HTLCs towards sender
204 pub max_accepted_htlcs: u16,
205 /// The sender's key controlling the funding transaction
206 pub funding_pubkey: PublicKey,
207 /// Used to derive a revocation key for transactions broadcast by counterparty
208 pub revocation_basepoint: PublicKey,
209 /// A payment key to sender for transactions broadcast by counterparty
210 pub payment_point: PublicKey,
211 /// Used to derive a payment key to sender for transactions broadcast by sender
212 pub delayed_payment_basepoint: PublicKey,
213 /// Used to derive an HTLC payment key to sender
214 pub htlc_basepoint: PublicKey,
215 /// The first to-be-broadcast-by-sender transaction's per commitment point
216 pub first_per_commitment_point: PublicKey,
217 /// The channel flags to be used
218 pub channel_flags: u8,
219 /// A request to pre-set the to-sender output's `scriptPubkey` for when we collaboratively close
220 pub shutdown_scriptpubkey: Option<Script>,
221 /// The channel type that this channel will represent
223 /// If this is `None`, we derive the channel type from the intersection of our
224 /// feature bits with our counterparty's feature bits from the [`Init`] message.
225 pub channel_type: Option<ChannelTypeFeatures>,
228 /// An open_channel2 message to be sent by or received from the channel initiator.
230 /// Used in V2 channel establishment
232 // TODO(dual_funding): Add spec link for `open_channel2`.
233 #[derive(Clone, Debug, PartialEq, Eq)]
234 pub struct OpenChannelV2 {
235 /// The genesis hash of the blockchain where the channel is to be opened
236 pub chain_hash: ChainHash,
237 /// A temporary channel ID derived using a zeroed out value for the channel acceptor's revocation basepoint
238 pub temporary_channel_id: ChannelId,
239 /// The feerate for the funding transaction set by the channel initiator
240 pub funding_feerate_sat_per_1000_weight: u32,
241 /// The feerate for the commitment transaction set by the channel initiator
242 pub commitment_feerate_sat_per_1000_weight: u32,
243 /// Part of the channel value contributed by the channel initiator
244 pub funding_satoshis: u64,
245 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
247 pub dust_limit_satoshis: u64,
248 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
249 pub max_htlc_value_in_flight_msat: u64,
250 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
251 pub htlc_minimum_msat: u64,
252 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
253 /// broadcast a commitment transaction
254 pub to_self_delay: u16,
255 /// The maximum number of inbound HTLCs towards channel initiator
256 pub max_accepted_htlcs: u16,
257 /// The locktime for the funding transaction
259 /// The channel initiator's key controlling the funding transaction
260 pub funding_pubkey: PublicKey,
261 /// Used to derive a revocation key for transactions broadcast by counterparty
262 pub revocation_basepoint: PublicKey,
263 /// A payment key to channel initiator for transactions broadcast by counterparty
264 pub payment_basepoint: PublicKey,
265 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
267 pub delayed_payment_basepoint: PublicKey,
268 /// Used to derive an HTLC payment key to channel initiator
269 pub htlc_basepoint: PublicKey,
270 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
271 pub first_per_commitment_point: PublicKey,
272 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
273 pub second_per_commitment_point: PublicKey,
275 pub channel_flags: u8,
276 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
277 /// collaboratively close
278 pub shutdown_scriptpubkey: Option<Script>,
279 /// The channel type that this channel will represent. If none is set, we derive the channel
280 /// type from the intersection of our feature bits with our counterparty's feature bits from
281 /// the Init message.
282 pub channel_type: Option<ChannelTypeFeatures>,
283 /// Optionally, a requirement that only confirmed inputs can be added
284 pub require_confirmed_inputs: Option<()>,
287 /// An [`accept_channel`] message to be sent to or received from a peer.
289 /// Used in V1 channel establishment
291 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
292 #[derive(Clone, Debug, PartialEq, Eq)]
293 pub struct AcceptChannel {
294 /// A temporary channel ID, until the funding outpoint is announced
295 pub temporary_channel_id: ChannelId,
296 /// The threshold below which outputs on transactions broadcast by sender will be omitted
297 pub dust_limit_satoshis: u64,
298 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
299 pub max_htlc_value_in_flight_msat: u64,
300 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
301 pub channel_reserve_satoshis: u64,
302 /// The minimum HTLC size incoming to sender, in milli-satoshi
303 pub htlc_minimum_msat: u64,
304 /// Minimum depth of the funding transaction before the channel is considered open
305 pub minimum_depth: u32,
306 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
307 pub to_self_delay: u16,
308 /// The maximum number of inbound HTLCs towards sender
309 pub max_accepted_htlcs: u16,
310 /// The sender's key controlling the funding transaction
311 pub funding_pubkey: PublicKey,
312 /// Used to derive a revocation key for transactions broadcast by counterparty
313 pub revocation_basepoint: PublicKey,
314 /// A payment key to sender for transactions broadcast by counterparty
315 pub payment_point: PublicKey,
316 /// Used to derive a payment key to sender for transactions broadcast by sender
317 pub delayed_payment_basepoint: PublicKey,
318 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
319 pub htlc_basepoint: PublicKey,
320 /// The first to-be-broadcast-by-sender transaction's per commitment point
321 pub first_per_commitment_point: PublicKey,
322 /// A request to pre-set the to-sender output's scriptPubkey for when we collaboratively close
323 pub shutdown_scriptpubkey: Option<Script>,
324 /// The channel type that this channel will represent.
326 /// If this is `None`, we derive the channel type from the intersection of
327 /// our feature bits with our counterparty's feature bits from the [`Init`] message.
328 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
329 pub channel_type: Option<ChannelTypeFeatures>,
331 /// Next nonce the channel initiator should use to create a funding output signature against
332 pub next_local_nonce: Option<musig2::types::PublicNonce>,
335 /// An accept_channel2 message to be sent by or received from the channel accepter.
337 /// Used in V2 channel establishment
339 // TODO(dual_funding): Add spec link for `accept_channel2`.
340 #[derive(Clone, Debug, PartialEq, Eq)]
341 pub struct AcceptChannelV2 {
342 /// The same `temporary_channel_id` received from the initiator's `open_channel2` message.
343 pub temporary_channel_id: ChannelId,
344 /// Part of the channel value contributed by the channel acceptor
345 pub funding_satoshis: u64,
346 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
348 pub dust_limit_satoshis: u64,
349 /// The maximum inbound HTLC value in flight towards channel acceptor, in milli-satoshi
350 pub max_htlc_value_in_flight_msat: u64,
351 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
352 pub htlc_minimum_msat: u64,
353 /// Minimum depth of the funding transaction before the channel is considered open
354 pub minimum_depth: u32,
355 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
356 /// broadcast a commitment transaction
357 pub to_self_delay: u16,
358 /// The maximum number of inbound HTLCs towards channel acceptor
359 pub max_accepted_htlcs: u16,
360 /// The channel acceptor's key controlling the funding transaction
361 pub funding_pubkey: PublicKey,
362 /// Used to derive a revocation key for transactions broadcast by counterparty
363 pub revocation_basepoint: PublicKey,
364 /// A payment key to channel acceptor for transactions broadcast by counterparty
365 pub payment_basepoint: PublicKey,
366 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
368 pub delayed_payment_basepoint: PublicKey,
369 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
370 pub htlc_basepoint: PublicKey,
371 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
372 pub first_per_commitment_point: PublicKey,
373 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
374 pub second_per_commitment_point: PublicKey,
375 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
376 /// collaboratively close
377 pub shutdown_scriptpubkey: Option<Script>,
378 /// The channel type that this channel will represent. If none is set, we derive the channel
379 /// type from the intersection of our feature bits with our counterparty's feature bits from
380 /// the Init message.
382 /// This is required to match the equivalent field in [`OpenChannelV2::channel_type`].
383 pub channel_type: Option<ChannelTypeFeatures>,
384 /// Optionally, a requirement that only confirmed inputs can be added
385 pub require_confirmed_inputs: Option<()>,
388 /// A [`funding_created`] message to be sent to or received from a peer.
390 /// Used in V1 channel establishment
392 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
393 #[derive(Clone, Debug, PartialEq, Eq)]
394 pub struct FundingCreated {
395 /// A temporary channel ID, until the funding is established
396 pub temporary_channel_id: ChannelId,
397 /// The funding transaction ID
398 pub funding_txid: Txid,
399 /// The specific output index funding this channel
400 pub funding_output_index: u16,
401 /// The signature of the channel initiator (funder) on the initial commitment transaction
402 pub signature: Signature,
404 /// The partial signature of the channel initiator (funder)
405 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
407 /// Next nonce the channel acceptor should use to finalize the funding output signature
408 pub next_local_nonce: Option<musig2::types::PublicNonce>
411 /// A [`funding_signed`] message to be sent to or received from a peer.
413 /// Used in V1 channel establishment
415 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
416 #[derive(Clone, Debug, PartialEq, Eq)]
417 pub struct FundingSigned {
419 pub channel_id: ChannelId,
420 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
421 pub signature: Signature,
423 /// The partial signature of the channel acceptor (fundee)
424 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
427 /// A [`channel_ready`] message to be sent to or received from a peer.
429 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
430 #[derive(Clone, Debug, PartialEq, Eq)]
431 pub struct ChannelReady {
433 pub channel_id: ChannelId,
434 /// The per-commitment point of the second commitment transaction
435 pub next_per_commitment_point: PublicKey,
436 /// If set, provides a `short_channel_id` alias for this channel.
438 /// The sender will accept payments to be forwarded over this SCID and forward them to this
439 /// messages' recipient.
440 pub short_channel_id_alias: Option<u64>,
443 /// A tx_add_input message for adding an input during interactive transaction construction
445 // TODO(dual_funding): Add spec link for `tx_add_input`.
446 #[derive(Clone, Debug, PartialEq, Eq)]
447 pub struct TxAddInput {
449 pub channel_id: ChannelId,
450 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
453 /// Serialized transaction that contains the output this input spends to verify that it is non
455 pub prevtx: TransactionU16LenLimited,
456 /// The index of the output being spent
458 /// The sequence number of this input
462 /// A tx_add_output message for adding an output during interactive transaction construction.
464 // TODO(dual_funding): Add spec link for `tx_add_output`.
465 #[derive(Clone, Debug, PartialEq, Eq)]
466 pub struct TxAddOutput {
468 pub channel_id: ChannelId,
469 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
472 /// The satoshi value of the output
474 /// The scriptPubKey for the output
478 /// A tx_remove_input message for removing an input during interactive transaction construction.
480 // TODO(dual_funding): Add spec link for `tx_remove_input`.
481 #[derive(Clone, Debug, PartialEq, Eq)]
482 pub struct TxRemoveInput {
484 pub channel_id: ChannelId,
485 /// The serial ID of the input to be removed
489 /// A tx_remove_output message for removing an output during interactive transaction construction.
491 // TODO(dual_funding): Add spec link for `tx_remove_output`.
492 #[derive(Clone, Debug, PartialEq, Eq)]
493 pub struct TxRemoveOutput {
495 pub channel_id: ChannelId,
496 /// The serial ID of the output to be removed
500 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
501 /// interactive transaction construction.
503 // TODO(dual_funding): Add spec link for `tx_complete`.
504 #[derive(Clone, Debug, PartialEq, Eq)]
505 pub struct TxComplete {
507 pub channel_id: ChannelId,
510 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
511 /// interactive transaction construction.
513 // TODO(dual_funding): Add spec link for `tx_signatures`.
514 #[derive(Clone, Debug, PartialEq, Eq)]
515 pub struct TxSignatures {
517 pub channel_id: ChannelId,
520 /// The list of witnesses
521 pub witnesses: Vec<Witness>,
524 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
527 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
528 #[derive(Clone, Debug, PartialEq, Eq)]
529 pub struct TxInitRbf {
531 pub channel_id: ChannelId,
532 /// The locktime of the transaction
534 /// The feerate of the transaction
535 pub feerate_sat_per_1000_weight: u32,
536 /// The number of satoshis the sender will contribute to or, if negative, remove from
537 /// (e.g. splice-out) the funding output of the transaction
538 pub funding_output_contribution: Option<i64>,
541 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
544 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
545 #[derive(Clone, Debug, PartialEq, Eq)]
546 pub struct TxAckRbf {
548 pub channel_id: ChannelId,
549 /// The number of satoshis the sender will contribute to or, if negative, remove from
550 /// (e.g. splice-out) the funding output of the transaction
551 pub funding_output_contribution: Option<i64>,
554 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
556 // TODO(dual_funding): Add spec link for `tx_abort`.
557 #[derive(Clone, Debug, PartialEq, Eq)]
560 pub channel_id: ChannelId,
565 /// A [`shutdown`] message to be sent to or received from a peer.
567 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
568 #[derive(Clone, Debug, PartialEq, Eq)]
569 pub struct Shutdown {
571 pub channel_id: ChannelId,
572 /// The destination of this peer's funds on closing.
574 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
575 pub scriptpubkey: Script,
578 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
580 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
582 #[derive(Clone, Debug, PartialEq, Eq)]
583 pub struct ClosingSignedFeeRange {
584 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
586 pub min_fee_satoshis: u64,
587 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
589 pub max_fee_satoshis: u64,
592 /// A [`closing_signed`] message to be sent to or received from a peer.
594 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
595 #[derive(Clone, Debug, PartialEq, Eq)]
596 pub struct ClosingSigned {
598 pub channel_id: ChannelId,
599 /// The proposed total fee for the closing transaction
600 pub fee_satoshis: u64,
601 /// A signature on the closing transaction
602 pub signature: Signature,
603 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
605 pub fee_range: Option<ClosingSignedFeeRange>,
608 /// An [`update_add_htlc`] message to be sent to or received from a peer.
610 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
611 #[derive(Clone, Debug, PartialEq, Eq)]
612 pub struct UpdateAddHTLC {
614 pub channel_id: ChannelId,
617 /// The HTLC value in milli-satoshi
618 pub amount_msat: u64,
619 /// The payment hash, the pre-image of which controls HTLC redemption
620 pub payment_hash: PaymentHash,
621 /// The expiry height of the HTLC
622 pub cltv_expiry: u32,
623 /// The extra fee skimmed by the sender of this message. See
624 /// [`ChannelConfig::accept_underpaying_htlcs`].
626 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
627 pub skimmed_fee_msat: Option<u64>,
628 pub(crate) onion_routing_packet: OnionPacket,
631 /// An onion message to be sent to or received from a peer.
633 // TODO: update with link to OM when they are merged into the BOLTs
634 #[derive(Clone, Debug, PartialEq, Eq)]
635 pub struct OnionMessage {
636 /// Used in decrypting the onion packet's payload.
637 pub blinding_point: PublicKey,
638 /// The full onion packet including hop data, pubkey, and hmac
639 pub onion_routing_packet: onion_message::Packet,
642 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
644 /// [`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
645 #[derive(Clone, Debug, PartialEq, Eq)]
646 pub struct UpdateFulfillHTLC {
648 pub channel_id: ChannelId,
651 /// The pre-image of the payment hash, allowing HTLC redemption
652 pub payment_preimage: PaymentPreimage,
655 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
657 /// [`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
658 #[derive(Clone, Debug, PartialEq, Eq)]
659 pub struct UpdateFailHTLC {
661 pub channel_id: ChannelId,
664 pub(crate) reason: OnionErrorPacket,
667 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
669 /// [`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
670 #[derive(Clone, Debug, PartialEq, Eq)]
671 pub struct UpdateFailMalformedHTLC {
673 pub channel_id: ChannelId,
676 pub(crate) sha256_of_onion: [u8; 32],
678 pub failure_code: u16,
681 /// A [`commitment_signed`] message to be sent to or received from a peer.
683 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
684 #[derive(Clone, Debug, PartialEq, Eq)]
685 pub struct CommitmentSigned {
687 pub channel_id: ChannelId,
688 /// A signature on the commitment transaction
689 pub signature: Signature,
690 /// Signatures on the HTLC transactions
691 pub htlc_signatures: Vec<Signature>,
693 /// The partial Taproot signature on the commitment transaction
694 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
697 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
699 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
700 #[derive(Clone, Debug, PartialEq, Eq)]
701 pub struct RevokeAndACK {
703 pub channel_id: ChannelId,
704 /// The secret corresponding to the per-commitment point
705 pub per_commitment_secret: [u8; 32],
706 /// The next sender-broadcast commitment transaction's per-commitment point
707 pub next_per_commitment_point: PublicKey,
709 /// Musig nonce the recipient should use in their next commitment signature message
710 pub next_local_nonce: Option<musig2::types::PublicNonce>
713 /// An [`update_fee`] message to be sent to or received from a peer
715 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
716 #[derive(Clone, Debug, PartialEq, Eq)]
717 pub struct UpdateFee {
719 pub channel_id: ChannelId,
720 /// Fee rate per 1000-weight of the transaction
721 pub feerate_per_kw: u32,
724 /// A [`channel_reestablish`] message to be sent to or received from a peer.
726 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
727 #[derive(Clone, Debug, PartialEq, Eq)]
728 pub struct ChannelReestablish {
730 pub channel_id: ChannelId,
731 /// The next commitment number for the sender
732 pub next_local_commitment_number: u64,
733 /// The next commitment number for the recipient
734 pub next_remote_commitment_number: u64,
735 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
736 /// belonging to the recipient
737 pub your_last_per_commitment_secret: [u8; 32],
738 /// The sender's per-commitment point for their current commitment transaction
739 pub my_current_per_commitment_point: PublicKey,
740 /// The next funding transaction ID
741 pub next_funding_txid: Option<Txid>,
744 /// An [`announcement_signatures`] message to be sent to or received from a peer.
746 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
747 #[derive(Clone, Debug, PartialEq, Eq)]
748 pub struct AnnouncementSignatures {
750 pub channel_id: ChannelId,
751 /// The short channel ID
752 pub short_channel_id: u64,
753 /// A signature by the node key
754 pub node_signature: Signature,
755 /// A signature by the funding key
756 pub bitcoin_signature: Signature,
759 /// An address which can be used to connect to a remote peer.
760 #[derive(Clone, Debug, PartialEq, Eq)]
761 pub enum SocketAddress {
762 /// An IPv4 address and port on which the peer is listening.
764 /// The 4-byte IPv4 address
766 /// The port on which the node is listening
769 /// An IPv6 address and port on which the peer is listening.
771 /// The 16-byte IPv6 address
773 /// The port on which the node is listening
776 /// An old-style Tor onion address/port on which the peer is listening.
778 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
779 /// addresses. Thus, the details are not parsed here.
781 /// A new-style Tor onion address/port on which the peer is listening.
783 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
784 /// wrap as base32 and append ".onion".
786 /// The ed25519 long-term public key of the peer
787 ed25519_pubkey: [u8; 32],
788 /// The checksum of the pubkey and version, as included in the onion address
790 /// The version byte, as defined by the Tor Onion v3 spec.
792 /// The port on which the node is listening
795 /// A hostname/port on which the peer is listening.
797 /// The hostname on which the node is listening.
799 /// The port on which the node is listening.
804 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
806 pub(crate) fn get_id(&self) -> u8 {
808 &SocketAddress::TcpIpV4 {..} => { 1 },
809 &SocketAddress::TcpIpV6 {..} => { 2 },
810 &SocketAddress::OnionV2(_) => { 3 },
811 &SocketAddress::OnionV3 {..} => { 4 },
812 &SocketAddress::Hostname {..} => { 5 },
816 /// Strict byte-length of address descriptor, 1-byte type not recorded
817 fn len(&self) -> u16 {
819 &SocketAddress::TcpIpV4 { .. } => { 6 },
820 &SocketAddress::TcpIpV6 { .. } => { 18 },
821 &SocketAddress::OnionV2(_) => { 12 },
822 &SocketAddress::OnionV3 { .. } => { 37 },
823 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
824 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
828 /// The maximum length of any address descriptor, not including the 1-byte type.
829 /// This maximum length is reached by a hostname address descriptor:
830 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
831 pub(crate) const MAX_LEN: u16 = 258;
834 impl Writeable for SocketAddress {
835 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
837 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
842 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
847 &SocketAddress::OnionV2(bytes) => {
849 bytes.write(writer)?;
851 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
853 ed25519_pubkey.write(writer)?;
854 checksum.write(writer)?;
855 version.write(writer)?;
858 &SocketAddress::Hostname { ref hostname, ref port } => {
860 hostname.write(writer)?;
868 impl Readable for Result<SocketAddress, u8> {
869 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
870 let byte = <u8 as Readable>::read(reader)?;
873 Ok(Ok(SocketAddress::TcpIpV4 {
874 addr: Readable::read(reader)?,
875 port: Readable::read(reader)?,
879 Ok(Ok(SocketAddress::TcpIpV6 {
880 addr: Readable::read(reader)?,
881 port: Readable::read(reader)?,
884 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
886 Ok(Ok(SocketAddress::OnionV3 {
887 ed25519_pubkey: Readable::read(reader)?,
888 checksum: Readable::read(reader)?,
889 version: Readable::read(reader)?,
890 port: Readable::read(reader)?,
894 Ok(Ok(SocketAddress::Hostname {
895 hostname: Readable::read(reader)?,
896 port: Readable::read(reader)?,
899 _ => return Ok(Err(byte)),
904 impl Readable for SocketAddress {
905 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
906 match Readable::read(reader) {
907 Ok(Ok(res)) => Ok(res),
908 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
914 /// [`SocketAddress`] error variants
915 #[derive(Debug, Eq, PartialEq, Clone)]
916 pub enum SocketAddressParseError {
917 /// Socket address (IPv4/IPv6) parsing error
919 /// Invalid input format
923 /// Invalid onion v3 address
927 impl fmt::Display for SocketAddressParseError {
928 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
930 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
931 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
932 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
933 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
934 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
939 #[cfg(feature = "std")]
940 impl From<std::net::SocketAddrV4> for SocketAddress {
941 fn from(addr: std::net::SocketAddrV4) -> Self {
942 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
946 #[cfg(feature = "std")]
947 impl From<std::net::SocketAddrV6> for SocketAddress {
948 fn from(addr: std::net::SocketAddrV6) -> Self {
949 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
953 #[cfg(feature = "std")]
954 impl From<std::net::SocketAddr> for SocketAddress {
955 fn from(addr: std::net::SocketAddr) -> Self {
957 std::net::SocketAddr::V4(addr) => addr.into(),
958 std::net::SocketAddr::V6(addr) => addr.into(),
963 #[cfg(feature = "std")]
964 impl std::net::ToSocketAddrs for SocketAddress {
965 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
967 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
969 SocketAddress::TcpIpV4 { addr, port } => {
970 let ip_addr = std::net::Ipv4Addr::from(*addr);
971 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
972 Ok(vec![socket_addr].into_iter())
974 SocketAddress::TcpIpV6 { addr, port } => {
975 let ip_addr = std::net::Ipv6Addr::from(*addr);
976 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
977 Ok(vec![socket_addr].into_iter())
979 SocketAddress::Hostname { ref hostname, port } => {
980 (hostname.as_str(), *port).to_socket_addrs()
982 SocketAddress::OnionV2(..) => {
983 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
984 addresses is currently unsupported."))
986 SocketAddress::OnionV3 { .. } => {
987 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
988 addresses is currently unsupported."))
994 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
996 /// The host part must end with ".onion".
997 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
998 if host.ends_with(".onion") {
999 let domain = &host[..host.len() - ".onion".len()];
1000 if domain.len() != 56 {
1001 return Err(SocketAddressParseError::InvalidOnionV3);
1003 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1004 if onion.len() != 35 {
1005 return Err(SocketAddressParseError::InvalidOnionV3);
1007 let version = onion[0];
1008 let first_checksum_flag = onion[1];
1009 let second_checksum_flag = onion[2];
1010 let mut ed25519_pubkey = [0; 32];
1011 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1012 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1013 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1016 return Err(SocketAddressParseError::InvalidInput);
1020 #[cfg(feature = "std")]
1021 impl FromStr for SocketAddress {
1022 type Err = SocketAddressParseError;
1024 fn from_str(s: &str) -> Result<Self, Self::Err> {
1025 match std::net::SocketAddr::from_str(s) {
1026 Ok(addr) => Ok(addr.into()),
1028 let trimmed_input = match s.rfind(":") {
1030 None => return Err(SocketAddressParseError::InvalidInput),
1032 let host = &s[..trimmed_input];
1033 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1034 if host.ends_with(".onion") {
1035 return parse_onion_address(host, port);
1037 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1038 return Ok(SocketAddress::Hostname { hostname, port });
1040 return Err(SocketAddressParseError::SocketAddrParse)
1046 /// Represents the set of gossip messages that require a signature from a node's identity key.
1047 pub enum UnsignedGossipMessage<'a> {
1048 /// An unsigned channel announcement.
1049 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1050 /// An unsigned channel update.
1051 ChannelUpdate(&'a UnsignedChannelUpdate),
1052 /// An unsigned node announcement.
1053 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1056 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1057 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1059 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1060 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1061 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1066 /// The unsigned part of a [`node_announcement`] message.
1068 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1069 #[derive(Clone, Debug, PartialEq, Eq)]
1070 pub struct UnsignedNodeAnnouncement {
1071 /// The advertised features
1072 pub features: NodeFeatures,
1073 /// A strictly monotonic announcement counter, with gaps allowed
1075 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1077 pub node_id: NodeId,
1078 /// An RGB color for UI purposes
1080 /// An alias, for UI purposes.
1082 /// This should be sanitized before use. There is no guarantee of uniqueness.
1083 pub alias: NodeAlias,
1084 /// List of addresses on which this node is reachable
1085 pub addresses: Vec<SocketAddress>,
1086 pub(crate) excess_address_data: Vec<u8>,
1087 pub(crate) excess_data: Vec<u8>,
1089 #[derive(Clone, Debug, PartialEq, Eq)]
1090 /// A [`node_announcement`] message to be sent to or received from a peer.
1092 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1093 pub struct NodeAnnouncement {
1094 /// The signature by the node key
1095 pub signature: Signature,
1096 /// The actual content of the announcement
1097 pub contents: UnsignedNodeAnnouncement,
1100 /// The unsigned part of a [`channel_announcement`] message.
1102 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1103 #[derive(Clone, Debug, PartialEq, Eq)]
1104 pub struct UnsignedChannelAnnouncement {
1105 /// The advertised channel features
1106 pub features: ChannelFeatures,
1107 /// The genesis hash of the blockchain where the channel is to be opened
1108 pub chain_hash: ChainHash,
1109 /// The short channel ID
1110 pub short_channel_id: u64,
1111 /// One of the two `node_id`s which are endpoints of this channel
1112 pub node_id_1: NodeId,
1113 /// The other of the two `node_id`s which are endpoints of this channel
1114 pub node_id_2: NodeId,
1115 /// The funding key for the first node
1116 pub bitcoin_key_1: NodeId,
1117 /// The funding key for the second node
1118 pub bitcoin_key_2: NodeId,
1119 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1122 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1123 pub excess_data: Vec<u8>,
1125 /// A [`channel_announcement`] message to be sent to or received from a peer.
1127 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1128 #[derive(Clone, Debug, PartialEq, Eq)]
1129 pub struct ChannelAnnouncement {
1130 /// Authentication of the announcement by the first public node
1131 pub node_signature_1: Signature,
1132 /// Authentication of the announcement by the second public node
1133 pub node_signature_2: Signature,
1134 /// Proof of funding UTXO ownership by the first public node
1135 pub bitcoin_signature_1: Signature,
1136 /// Proof of funding UTXO ownership by the second public node
1137 pub bitcoin_signature_2: Signature,
1138 /// The actual announcement
1139 pub contents: UnsignedChannelAnnouncement,
1142 /// The unsigned part of a [`channel_update`] message.
1144 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1145 #[derive(Clone, Debug, PartialEq, Eq)]
1146 pub struct UnsignedChannelUpdate {
1147 /// The genesis hash of the blockchain where the channel is to be opened
1148 pub chain_hash: ChainHash,
1149 /// The short channel ID
1150 pub short_channel_id: u64,
1151 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1155 /// The number of blocks such that if:
1156 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1157 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1158 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1159 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1160 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1161 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1162 /// constructing the route.
1163 pub cltv_expiry_delta: u16,
1164 /// The minimum HTLC size incoming to sender, in milli-satoshi
1165 pub htlc_minimum_msat: u64,
1166 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1168 /// This used to be optional.
1169 pub htlc_maximum_msat: u64,
1170 /// The base HTLC fee charged by sender, in milli-satoshi
1171 pub fee_base_msat: u32,
1172 /// The amount to fee multiplier, in micro-satoshi
1173 pub fee_proportional_millionths: u32,
1174 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1177 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1178 pub excess_data: Vec<u8>,
1180 /// A [`channel_update`] message to be sent to or received from a peer.
1182 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1183 #[derive(Clone, Debug, PartialEq, Eq)]
1184 pub struct ChannelUpdate {
1185 /// A signature of the channel update
1186 pub signature: Signature,
1187 /// The actual channel update
1188 pub contents: UnsignedChannelUpdate,
1191 /// A [`query_channel_range`] message is used to query a peer for channel
1192 /// UTXOs in a range of blocks. The recipient of a query makes a best
1193 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1196 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1197 #[derive(Clone, Debug, PartialEq, Eq)]
1198 pub struct QueryChannelRange {
1199 /// The genesis hash of the blockchain being queried
1200 pub chain_hash: ChainHash,
1201 /// The height of the first block for the channel UTXOs being queried
1202 pub first_blocknum: u32,
1203 /// The number of blocks to include in the query results
1204 pub number_of_blocks: u32,
1207 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1210 /// Multiple `reply_channel_range` messages can be sent in reply
1211 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1212 /// best effort to respond based on their local network view which may
1213 /// not be a perfect view of the network. The `short_channel_id`s in the
1214 /// reply are encoded. We only support `encoding_type=0` uncompressed
1215 /// serialization and do not support `encoding_type=1` zlib serialization.
1217 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1218 #[derive(Clone, Debug, PartialEq, Eq)]
1219 pub struct ReplyChannelRange {
1220 /// The genesis hash of the blockchain being queried
1221 pub chain_hash: ChainHash,
1222 /// The height of the first block in the range of the reply
1223 pub first_blocknum: u32,
1224 /// The number of blocks included in the range of the reply
1225 pub number_of_blocks: u32,
1226 /// True when this is the final reply for a query
1227 pub sync_complete: bool,
1228 /// The `short_channel_id`s in the channel range
1229 pub short_channel_ids: Vec<u64>,
1232 /// A [`query_short_channel_ids`] message is used to query a peer for
1233 /// routing gossip messages related to one or more `short_channel_id`s.
1235 /// The query recipient will reply with the latest, if available,
1236 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1237 /// it maintains for the requested `short_channel_id`s followed by a
1238 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1239 /// this query are encoded. We only support `encoding_type=0` uncompressed
1240 /// serialization and do not support `encoding_type=1` zlib serialization.
1242 /// [`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
1243 #[derive(Clone, Debug, PartialEq, Eq)]
1244 pub struct QueryShortChannelIds {
1245 /// The genesis hash of the blockchain being queried
1246 pub chain_hash: ChainHash,
1247 /// The short_channel_ids that are being queried
1248 pub short_channel_ids: Vec<u64>,
1251 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1252 /// message. The query recipient makes a best
1253 /// effort to respond based on their local network view which may not be
1254 /// a perfect view of the network.
1256 /// [`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
1257 #[derive(Clone, Debug, PartialEq, Eq)]
1258 pub struct ReplyShortChannelIdsEnd {
1259 /// The genesis hash of the blockchain that was queried
1260 pub chain_hash: ChainHash,
1261 /// Indicates if the query recipient maintains up-to-date channel
1262 /// information for the `chain_hash`
1263 pub full_information: bool,
1266 /// A [`gossip_timestamp_filter`] message is used by a node to request
1267 /// gossip relay for messages in the requested time range when the
1268 /// `gossip_queries` feature has been negotiated.
1270 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1271 #[derive(Clone, Debug, PartialEq, Eq)]
1272 pub struct GossipTimestampFilter {
1273 /// The genesis hash of the blockchain for channel and node information
1274 pub chain_hash: ChainHash,
1275 /// The starting unix timestamp
1276 pub first_timestamp: u32,
1277 /// The range of information in seconds
1278 pub timestamp_range: u32,
1281 /// Encoding type for data compression of collections in gossip queries.
1283 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1284 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1286 Uncompressed = 0x00,
1289 /// Used to put an error message in a [`LightningError`].
1290 #[derive(Clone, Debug, PartialEq)]
1291 pub enum ErrorAction {
1292 /// The peer took some action which made us think they were useless. Disconnect them.
1294 /// An error message which we should make an effort to send before we disconnect.
1295 msg: Option<ErrorMessage>
1297 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1298 DisconnectPeerWithWarning {
1299 /// A warning message which we should make an effort to send before we disconnect.
1300 msg: WarningMessage,
1302 /// The peer did something harmless that we weren't able to process, just log and ignore
1303 // New code should *not* use this. New code must use IgnoreAndLog, below!
1305 /// The peer did something harmless that we weren't able to meaningfully process.
1306 /// If the error is logged, log it at the given level.
1307 IgnoreAndLog(logger::Level),
1308 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1309 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1310 /// our own channel announcements.
1311 IgnoreDuplicateGossip,
1312 /// The peer did something incorrect. Tell them.
1314 /// The message to send.
1317 /// The peer did something incorrect. Tell them without closing any channels.
1318 SendWarningMessage {
1319 /// The message to send.
1320 msg: WarningMessage,
1321 /// The peer may have done something harmless that we weren't able to meaningfully process,
1322 /// though we should still tell them about it.
1323 /// If this event is logged, log it at the given level.
1324 log_level: logger::Level,
1328 /// An Err type for failure to process messages.
1329 #[derive(Clone, Debug)]
1330 pub struct LightningError {
1331 /// A human-readable message describing the error
1333 /// The action which should be taken against the offending peer.
1334 pub action: ErrorAction,
1337 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1338 /// transaction updates if they were pending.
1339 #[derive(Clone, Debug, PartialEq, Eq)]
1340 pub struct CommitmentUpdate {
1341 /// `update_add_htlc` messages which should be sent
1342 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1343 /// `update_fulfill_htlc` messages which should be sent
1344 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1345 /// `update_fail_htlc` messages which should be sent
1346 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1347 /// `update_fail_malformed_htlc` messages which should be sent
1348 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1349 /// An `update_fee` message which should be sent
1350 pub update_fee: Option<UpdateFee>,
1351 /// A `commitment_signed` message which should be sent
1352 pub commitment_signed: CommitmentSigned,
1355 /// A trait to describe an object which can receive channel messages.
1357 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1358 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1359 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1361 /// Handle an incoming `open_channel` message from the given peer.
1362 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1363 /// Handle an incoming `open_channel2` message from the given peer.
1364 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1365 /// Handle an incoming `accept_channel` message from the given peer.
1366 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1367 /// Handle an incoming `accept_channel2` message from the given peer.
1368 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1369 /// Handle an incoming `funding_created` message from the given peer.
1370 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1371 /// Handle an incoming `funding_signed` message from the given peer.
1372 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1373 /// Handle an incoming `channel_ready` message from the given peer.
1374 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1377 /// Handle an incoming `shutdown` message from the given peer.
1378 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1379 /// Handle an incoming `closing_signed` message from the given peer.
1380 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1382 // Interactive channel construction
1383 /// Handle an incoming `tx_add_input message` from the given peer.
1384 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1385 /// Handle an incoming `tx_add_output` message from the given peer.
1386 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1387 /// Handle an incoming `tx_remove_input` message from the given peer.
1388 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1389 /// Handle an incoming `tx_remove_output` message from the given peer.
1390 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1391 /// Handle an incoming `tx_complete message` from the given peer.
1392 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1393 /// Handle an incoming `tx_signatures` message from the given peer.
1394 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1395 /// Handle an incoming `tx_init_rbf` message from the given peer.
1396 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1397 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1398 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1399 /// Handle an incoming `tx_abort message` from the given peer.
1400 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1403 /// Handle an incoming `update_add_htlc` message from the given peer.
1404 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1405 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1406 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1407 /// Handle an incoming `update_fail_htlc` message from the given peer.
1408 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1409 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1410 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1411 /// Handle an incoming `commitment_signed` message from the given peer.
1412 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1413 /// Handle an incoming `revoke_and_ack` message from the given peer.
1414 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1416 /// Handle an incoming `update_fee` message from the given peer.
1417 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1419 // Channel-to-announce:
1420 /// Handle an incoming `announcement_signatures` message from the given peer.
1421 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1423 // Connection loss/reestablish:
1424 /// Indicates a connection to the peer failed/an existing connection was lost.
1425 fn peer_disconnected(&self, their_node_id: &PublicKey);
1427 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1429 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1430 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1431 /// message handlers may still wish to communicate with this peer.
1432 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1433 /// Handle an incoming `channel_reestablish` message from the given peer.
1434 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1436 /// Handle an incoming `channel_update` message from the given peer.
1437 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1440 /// Handle an incoming `error` message from the given peer.
1441 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1443 // Handler information:
1444 /// Gets the node feature flags which this handler itself supports. All available handlers are
1445 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1446 /// which are broadcasted in our [`NodeAnnouncement`] message.
1447 fn provided_node_features(&self) -> NodeFeatures;
1449 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1450 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1451 /// which are sent in our [`Init`] message.
1453 /// Note that this method is called before [`Self::peer_connected`].
1454 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1456 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1458 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1459 /// connecting to peers.
1460 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1463 /// A trait to describe an object which can receive routing messages.
1465 /// # Implementor DoS Warnings
1467 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1468 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1469 /// repeated disk I/O for queries accessing different parts of the network graph.
1470 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1471 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1472 /// `false` or returning an `Err` otherwise.
1473 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1474 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1475 /// or returning an `Err` otherwise.
1476 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1477 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1478 /// `false` or returning an `Err` otherwise.
1479 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1480 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1481 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1482 /// for a single channel.
1483 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1484 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1485 /// the node *after* the provided pubkey and including up to one announcement immediately
1486 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1487 /// If `None` is provided for `starting_point`, we start at the first node.
1488 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1489 /// Called when a connection is established with a peer. This can be used to
1490 /// perform routing table synchronization using a strategy defined by the
1493 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1494 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1495 /// message handlers may still wish to communicate with this peer.
1496 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1497 /// Handles the reply of a query we initiated to learn about channels
1498 /// for a given range of blocks. We can expect to receive one or more
1499 /// replies to a single query.
1500 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1501 /// Handles the reply of a query we initiated asking for routing gossip
1502 /// messages for a list of channels. We should receive this message when
1503 /// a node has completed its best effort to send us the pertaining routing
1504 /// gossip messages.
1505 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1506 /// Handles when a peer asks us to send a list of `short_channel_id`s
1507 /// for the requested range of blocks.
1508 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1509 /// Handles when a peer asks us to send routing gossip messages for a
1510 /// list of `short_channel_id`s.
1511 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1513 // Handler queueing status:
1514 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1515 /// pending some async action. While there is no guarantee of the rate of future messages, the
1516 /// caller should seek to reduce the rate of new gossip messages handled, especially
1517 /// [`ChannelAnnouncement`]s.
1518 fn processing_queue_high(&self) -> bool;
1520 // Handler information:
1521 /// Gets the node feature flags which this handler itself supports. All available handlers are
1522 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1523 /// which are broadcasted in our [`NodeAnnouncement`] message.
1524 fn provided_node_features(&self) -> NodeFeatures;
1525 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1526 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1527 /// which are sent in our [`Init`] message.
1529 /// Note that this method is called before [`Self::peer_connected`].
1530 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1533 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1534 pub trait OnionMessageHandler {
1535 /// Handle an incoming `onion_message` message from the given peer.
1536 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1538 /// Returns the next pending onion message for the peer with the given node id.
1539 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1541 /// Called when a connection is established with a peer. Can be used to track which peers
1542 /// advertise onion message support and are online.
1544 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1545 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1546 /// message handlers may still wish to communicate with this peer.
1547 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1549 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1550 /// drop and refuse to forward onion messages to this peer.
1551 fn peer_disconnected(&self, their_node_id: &PublicKey);
1553 // Handler information:
1554 /// Gets the node feature flags which this handler itself supports. All available handlers are
1555 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1556 /// which are broadcasted in our [`NodeAnnouncement`] message.
1557 fn provided_node_features(&self) -> NodeFeatures;
1559 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1560 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1561 /// which are sent in our [`Init`] message.
1563 /// Note that this method is called before [`Self::peer_connected`].
1564 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1567 mod fuzzy_internal_msgs {
1568 use bitcoin::secp256k1::PublicKey;
1569 use crate::blinded_path::payment::PaymentConstraints;
1570 use crate::prelude::*;
1571 use crate::ln::{PaymentPreimage, PaymentSecret};
1573 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1574 // them from untrusted input):
1576 pub struct FinalOnionHopData {
1577 pub payment_secret: PaymentSecret,
1578 /// The total value, in msat, of the payment as received by the ultimate recipient.
1579 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1580 pub total_msat: u64,
1583 pub enum InboundOnionPayload {
1585 short_channel_id: u64,
1586 /// The value, in msat, of the payment after this hop's fee is deducted.
1587 amt_to_forward: u64,
1588 outgoing_cltv_value: u32,
1591 payment_data: Option<FinalOnionHopData>,
1592 payment_metadata: Option<Vec<u8>>,
1593 keysend_preimage: Option<PaymentPreimage>,
1594 custom_tlvs: Vec<(u64, Vec<u8>)>,
1596 outgoing_cltv_value: u32,
1601 outgoing_cltv_value: u32,
1602 payment_secret: PaymentSecret,
1603 payment_constraints: PaymentConstraints,
1604 intro_node_blinding_point: PublicKey,
1608 pub(crate) enum OutboundOnionPayload {
1610 short_channel_id: u64,
1611 /// The value, in msat, of the payment after this hop's fee is deducted.
1612 amt_to_forward: u64,
1613 outgoing_cltv_value: u32,
1616 payment_data: Option<FinalOnionHopData>,
1617 payment_metadata: Option<Vec<u8>>,
1618 keysend_preimage: Option<PaymentPreimage>,
1619 custom_tlvs: Vec<(u64, Vec<u8>)>,
1621 outgoing_cltv_value: u32,
1624 encrypted_tlvs: Vec<u8>,
1625 intro_node_blinding_point: Option<PublicKey>,
1630 outgoing_cltv_value: u32,
1631 encrypted_tlvs: Vec<u8>,
1632 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1636 pub struct DecodedOnionErrorPacket {
1637 pub(crate) hmac: [u8; 32],
1638 pub(crate) failuremsg: Vec<u8>,
1639 pub(crate) pad: Vec<u8>,
1643 pub use self::fuzzy_internal_msgs::*;
1644 #[cfg(not(fuzzing))]
1645 pub(crate) use self::fuzzy_internal_msgs::*;
1648 pub(crate) struct OnionPacket {
1649 pub(crate) version: u8,
1650 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1651 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1652 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1653 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1655 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1656 pub(crate) hop_data: [u8; 20*65],
1657 pub(crate) hmac: [u8; 32],
1660 impl onion_utils::Packet for OnionPacket {
1661 type Data = onion_utils::FixedSizeOnionPacket;
1662 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1665 public_key: Ok(pubkey),
1666 hop_data: hop_data.0,
1672 impl Eq for OnionPacket { }
1673 impl PartialEq for OnionPacket {
1674 fn eq(&self, other: &OnionPacket) -> bool {
1675 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1676 if i != j { return false; }
1678 self.version == other.version &&
1679 self.public_key == other.public_key &&
1680 self.hmac == other.hmac
1684 impl fmt::Debug for OnionPacket {
1685 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1686 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1690 #[derive(Clone, Debug, PartialEq, Eq)]
1691 pub(crate) struct OnionErrorPacket {
1692 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1693 // (TODO) We limit it in decode to much lower...
1694 pub(crate) data: Vec<u8>,
1697 impl fmt::Display for DecodeError {
1698 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1700 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1701 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1702 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1703 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1704 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1705 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1706 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1711 impl From<io::Error> for DecodeError {
1712 fn from(e: io::Error) -> Self {
1713 if e.kind() == io::ErrorKind::UnexpectedEof {
1714 DecodeError::ShortRead
1716 DecodeError::Io(e.kind())
1721 #[cfg(not(taproot))]
1722 impl_writeable_msg!(AcceptChannel, {
1723 temporary_channel_id,
1724 dust_limit_satoshis,
1725 max_htlc_value_in_flight_msat,
1726 channel_reserve_satoshis,
1732 revocation_basepoint,
1734 delayed_payment_basepoint,
1736 first_per_commitment_point,
1738 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1739 (1, channel_type, option),
1743 impl_writeable_msg!(AcceptChannel, {
1744 temporary_channel_id,
1745 dust_limit_satoshis,
1746 max_htlc_value_in_flight_msat,
1747 channel_reserve_satoshis,
1753 revocation_basepoint,
1755 delayed_payment_basepoint,
1757 first_per_commitment_point,
1759 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1760 (1, channel_type, option),
1761 (4, next_local_nonce, option),
1764 impl_writeable_msg!(AcceptChannelV2, {
1765 temporary_channel_id,
1767 dust_limit_satoshis,
1768 max_htlc_value_in_flight_msat,
1774 revocation_basepoint,
1776 delayed_payment_basepoint,
1778 first_per_commitment_point,
1779 second_per_commitment_point,
1781 (0, shutdown_scriptpubkey, option),
1782 (1, channel_type, option),
1783 (2, require_confirmed_inputs, option),
1786 impl_writeable_msg!(TxAddInput, {
1794 impl_writeable_msg!(TxAddOutput, {
1801 impl_writeable_msg!(TxRemoveInput, {
1806 impl_writeable_msg!(TxRemoveOutput, {
1811 impl_writeable_msg!(TxComplete, {
1815 impl_writeable_msg!(TxSignatures, {
1821 impl_writeable_msg!(TxInitRbf, {
1824 feerate_sat_per_1000_weight,
1826 (0, funding_output_contribution, option),
1829 impl_writeable_msg!(TxAckRbf, {
1832 (0, funding_output_contribution, option),
1835 impl_writeable_msg!(TxAbort, {
1840 impl_writeable_msg!(AnnouncementSignatures, {
1847 impl_writeable_msg!(ChannelReestablish, {
1849 next_local_commitment_number,
1850 next_remote_commitment_number,
1851 your_last_per_commitment_secret,
1852 my_current_per_commitment_point,
1854 (0, next_funding_txid, option),
1857 impl_writeable_msg!(ClosingSigned,
1858 { channel_id, fee_satoshis, signature },
1859 { (1, fee_range, option) }
1862 impl_writeable!(ClosingSignedFeeRange, {
1867 #[cfg(not(taproot))]
1868 impl_writeable_msg!(CommitmentSigned, {
1875 impl_writeable_msg!(CommitmentSigned, {
1880 (2, partial_signature_with_nonce, option)
1883 impl_writeable!(DecodedOnionErrorPacket, {
1889 #[cfg(not(taproot))]
1890 impl_writeable_msg!(FundingCreated, {
1891 temporary_channel_id,
1893 funding_output_index,
1897 impl_writeable_msg!(FundingCreated, {
1898 temporary_channel_id,
1900 funding_output_index,
1903 (2, partial_signature_with_nonce, option),
1904 (4, next_local_nonce, option)
1907 #[cfg(not(taproot))]
1908 impl_writeable_msg!(FundingSigned, {
1914 impl_writeable_msg!(FundingSigned, {
1918 (2, partial_signature_with_nonce, option)
1921 impl_writeable_msg!(ChannelReady, {
1923 next_per_commitment_point,
1925 (1, short_channel_id_alias, option),
1928 impl Writeable for Init {
1929 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1930 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1931 // our relevant feature bits. This keeps us compatible with old nodes.
1932 self.features.write_up_to_13(w)?;
1933 self.features.write(w)?;
1934 encode_tlv_stream!(w, {
1935 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1936 (3, self.remote_network_address, option),
1942 impl Readable for Init {
1943 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1944 let global_features: InitFeatures = Readable::read(r)?;
1945 let features: InitFeatures = Readable::read(r)?;
1946 let mut remote_network_address: Option<SocketAddress> = None;
1947 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1948 decode_tlv_stream!(r, {
1949 (1, networks, option),
1950 (3, remote_network_address, option)
1953 features: features | global_features,
1954 networks: networks.map(|n| n.0),
1955 remote_network_address,
1960 impl_writeable_msg!(OpenChannel, {
1962 temporary_channel_id,
1965 dust_limit_satoshis,
1966 max_htlc_value_in_flight_msat,
1967 channel_reserve_satoshis,
1973 revocation_basepoint,
1975 delayed_payment_basepoint,
1977 first_per_commitment_point,
1980 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1981 (1, channel_type, option),
1984 impl_writeable_msg!(OpenChannelV2, {
1986 temporary_channel_id,
1987 funding_feerate_sat_per_1000_weight,
1988 commitment_feerate_sat_per_1000_weight,
1990 dust_limit_satoshis,
1991 max_htlc_value_in_flight_msat,
1997 revocation_basepoint,
1999 delayed_payment_basepoint,
2001 first_per_commitment_point,
2002 second_per_commitment_point,
2005 (0, shutdown_scriptpubkey, option),
2006 (1, channel_type, option),
2007 (2, require_confirmed_inputs, option),
2010 #[cfg(not(taproot))]
2011 impl_writeable_msg!(RevokeAndACK, {
2013 per_commitment_secret,
2014 next_per_commitment_point
2018 impl_writeable_msg!(RevokeAndACK, {
2020 per_commitment_secret,
2021 next_per_commitment_point
2023 (4, next_local_nonce, option)
2026 impl_writeable_msg!(Shutdown, {
2031 impl_writeable_msg!(UpdateFailHTLC, {
2037 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2044 impl_writeable_msg!(UpdateFee, {
2049 impl_writeable_msg!(UpdateFulfillHTLC, {
2055 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2056 // serialization format in a way which assumes we know the total serialized length/message end
2058 impl_writeable!(OnionErrorPacket, {
2062 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2063 // serialization format in a way which assumes we know the total serialized length/message end
2065 impl Writeable for OnionPacket {
2066 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2067 self.version.write(w)?;
2068 match self.public_key {
2069 Ok(pubkey) => pubkey.write(w)?,
2070 Err(_) => [0u8;33].write(w)?,
2072 w.write_all(&self.hop_data)?;
2073 self.hmac.write(w)?;
2078 impl Readable for OnionPacket {
2079 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2081 version: Readable::read(r)?,
2083 let mut buf = [0u8;33];
2084 r.read_exact(&mut buf)?;
2085 PublicKey::from_slice(&buf)
2087 hop_data: Readable::read(r)?,
2088 hmac: Readable::read(r)?,
2093 impl_writeable_msg!(UpdateAddHTLC, {
2099 onion_routing_packet,
2101 (65537, skimmed_fee_msat, option)
2104 impl Readable for OnionMessage {
2105 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2106 let blinding_point: PublicKey = Readable::read(r)?;
2107 let len: u16 = Readable::read(r)?;
2108 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2109 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2112 onion_routing_packet,
2117 impl Writeable for OnionMessage {
2118 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2119 self.blinding_point.write(w)?;
2120 let onion_packet_len = self.onion_routing_packet.serialized_length();
2121 (onion_packet_len as u16).write(w)?;
2122 self.onion_routing_packet.write(w)?;
2127 impl Writeable for FinalOnionHopData {
2128 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2129 self.payment_secret.0.write(w)?;
2130 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2134 impl Readable for FinalOnionHopData {
2135 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2136 let secret: [u8; 32] = Readable::read(r)?;
2137 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2138 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2142 impl Writeable for OutboundOnionPayload {
2143 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2145 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2146 _encode_varint_length_prefixed_tlv!(w, {
2147 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2148 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2149 (6, short_channel_id, required)
2153 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2154 outgoing_cltv_value, ref custom_tlvs,
2156 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2157 // to reject any reserved types in the experimental range if new ones are ever
2159 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2160 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2161 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2162 _encode_varint_length_prefixed_tlv!(w, {
2163 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2164 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2165 (8, payment_data, option),
2166 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2167 }, custom_tlvs.iter());
2169 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2170 _encode_varint_length_prefixed_tlv!(w, {
2171 (10, *encrypted_tlvs, required_vec),
2172 (12, intro_node_blinding_point, option)
2175 Self::BlindedReceive {
2176 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2177 intro_node_blinding_point,
2179 _encode_varint_length_prefixed_tlv!(w, {
2180 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2181 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2182 (10, *encrypted_tlvs, required_vec),
2183 (12, intro_node_blinding_point, option),
2184 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2192 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2193 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2195 let mut cltv_value = None;
2196 let mut short_id: Option<u64> = None;
2197 let mut payment_data: Option<FinalOnionHopData> = None;
2198 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2199 let mut intro_node_blinding_point = None;
2200 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2201 let mut total_msat = None;
2202 let mut keysend_preimage: Option<PaymentPreimage> = None;
2203 let mut custom_tlvs = Vec::new();
2205 let tlv_len = BigSize::read(r)?;
2206 let rd = FixedLengthReader::new(r, tlv_len.0);
2207 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2208 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2209 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2210 (6, short_id, option),
2211 (8, payment_data, option),
2212 (10, encrypted_tlvs_opt, option),
2213 (12, intro_node_blinding_point, option),
2214 (16, payment_metadata, option),
2215 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2216 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2217 (5482373484, keysend_preimage, option)
2218 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2219 if msg_type < 1 << 16 { return Ok(false) }
2220 let mut value = Vec::new();
2221 msg_reader.read_to_end(&mut value)?;
2222 custom_tlvs.push((msg_type, value));
2226 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2228 if let Some(blinding_point) = intro_node_blinding_point {
2229 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2230 return Err(DecodeError::InvalidValue)
2232 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2233 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2234 .map_err(|_| DecodeError::InvalidValue)?;
2235 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2236 let mut s = Cursor::new(&enc_tlvs);
2237 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2238 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2239 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2240 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2241 Ok(Self::BlindedReceive {
2242 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2243 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2244 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2246 payment_constraints,
2247 intro_node_blinding_point: blinding_point,
2251 } else if let Some(short_channel_id) = short_id {
2252 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2253 total_msat.is_some()
2254 { return Err(DecodeError::InvalidValue) }
2257 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2258 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2261 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2262 return Err(DecodeError::InvalidValue)
2264 if let Some(data) = &payment_data {
2265 if data.total_msat > MAX_VALUE_MSAT {
2266 return Err(DecodeError::InvalidValue);
2271 payment_metadata: payment_metadata.map(|w| w.0),
2273 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2274 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2281 impl Writeable for Ping {
2282 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2283 self.ponglen.write(w)?;
2284 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2289 impl Readable for Ping {
2290 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2292 ponglen: Readable::read(r)?,
2294 let byteslen = Readable::read(r)?;
2295 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2302 impl Writeable for Pong {
2303 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2304 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2309 impl Readable for Pong {
2310 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2313 let byteslen = Readable::read(r)?;
2314 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2321 impl Writeable for UnsignedChannelAnnouncement {
2322 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2323 self.features.write(w)?;
2324 self.chain_hash.write(w)?;
2325 self.short_channel_id.write(w)?;
2326 self.node_id_1.write(w)?;
2327 self.node_id_2.write(w)?;
2328 self.bitcoin_key_1.write(w)?;
2329 self.bitcoin_key_2.write(w)?;
2330 w.write_all(&self.excess_data[..])?;
2335 impl Readable for UnsignedChannelAnnouncement {
2336 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2338 features: Readable::read(r)?,
2339 chain_hash: Readable::read(r)?,
2340 short_channel_id: Readable::read(r)?,
2341 node_id_1: Readable::read(r)?,
2342 node_id_2: Readable::read(r)?,
2343 bitcoin_key_1: Readable::read(r)?,
2344 bitcoin_key_2: Readable::read(r)?,
2345 excess_data: read_to_end(r)?,
2350 impl_writeable!(ChannelAnnouncement, {
2353 bitcoin_signature_1,
2354 bitcoin_signature_2,
2358 impl Writeable for UnsignedChannelUpdate {
2359 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2360 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2361 const MESSAGE_FLAGS: u8 = 1;
2362 self.chain_hash.write(w)?;
2363 self.short_channel_id.write(w)?;
2364 self.timestamp.write(w)?;
2365 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2366 all_flags.write(w)?;
2367 self.cltv_expiry_delta.write(w)?;
2368 self.htlc_minimum_msat.write(w)?;
2369 self.fee_base_msat.write(w)?;
2370 self.fee_proportional_millionths.write(w)?;
2371 self.htlc_maximum_msat.write(w)?;
2372 w.write_all(&self.excess_data[..])?;
2377 impl Readable for UnsignedChannelUpdate {
2378 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2380 chain_hash: Readable::read(r)?,
2381 short_channel_id: Readable::read(r)?,
2382 timestamp: Readable::read(r)?,
2384 let flags: u16 = Readable::read(r)?;
2385 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2388 cltv_expiry_delta: Readable::read(r)?,
2389 htlc_minimum_msat: Readable::read(r)?,
2390 fee_base_msat: Readable::read(r)?,
2391 fee_proportional_millionths: Readable::read(r)?,
2392 htlc_maximum_msat: Readable::read(r)?,
2393 excess_data: read_to_end(r)?,
2398 impl_writeable!(ChannelUpdate, {
2403 impl Writeable for ErrorMessage {
2404 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2405 self.channel_id.write(w)?;
2406 (self.data.len() as u16).write(w)?;
2407 w.write_all(self.data.as_bytes())?;
2412 impl Readable for ErrorMessage {
2413 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2415 channel_id: Readable::read(r)?,
2417 let sz: usize = <u16 as Readable>::read(r)? as usize;
2418 let mut data = Vec::with_capacity(sz);
2420 r.read_exact(&mut data)?;
2421 match String::from_utf8(data) {
2423 Err(_) => return Err(DecodeError::InvalidValue),
2430 impl Writeable for WarningMessage {
2431 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2432 self.channel_id.write(w)?;
2433 (self.data.len() as u16).write(w)?;
2434 w.write_all(self.data.as_bytes())?;
2439 impl Readable for WarningMessage {
2440 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2442 channel_id: Readable::read(r)?,
2444 let sz: usize = <u16 as Readable>::read(r)? as usize;
2445 let mut data = Vec::with_capacity(sz);
2447 r.read_exact(&mut data)?;
2448 match String::from_utf8(data) {
2450 Err(_) => return Err(DecodeError::InvalidValue),
2457 impl Writeable for UnsignedNodeAnnouncement {
2458 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2459 self.features.write(w)?;
2460 self.timestamp.write(w)?;
2461 self.node_id.write(w)?;
2462 w.write_all(&self.rgb)?;
2463 self.alias.write(w)?;
2465 let mut addr_len = 0;
2466 for addr in self.addresses.iter() {
2467 addr_len += 1 + addr.len();
2469 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2470 for addr in self.addresses.iter() {
2473 w.write_all(&self.excess_address_data[..])?;
2474 w.write_all(&self.excess_data[..])?;
2479 impl Readable for UnsignedNodeAnnouncement {
2480 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2481 let features: NodeFeatures = Readable::read(r)?;
2482 let timestamp: u32 = Readable::read(r)?;
2483 let node_id: NodeId = Readable::read(r)?;
2484 let mut rgb = [0; 3];
2485 r.read_exact(&mut rgb)?;
2486 let alias: NodeAlias = Readable::read(r)?;
2488 let addr_len: u16 = Readable::read(r)?;
2489 let mut addresses: Vec<SocketAddress> = Vec::new();
2490 let mut addr_readpos = 0;
2491 let mut excess = false;
2492 let mut excess_byte = 0;
2494 if addr_len <= addr_readpos { break; }
2495 match Readable::read(r) {
2497 if addr_len < addr_readpos + 1 + addr.len() {
2498 return Err(DecodeError::BadLengthDescriptor);
2500 addr_readpos += (1 + addr.len()) as u16;
2501 addresses.push(addr);
2503 Ok(Err(unknown_descriptor)) => {
2505 excess_byte = unknown_descriptor;
2508 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2509 Err(e) => return Err(e),
2513 let mut excess_data = vec![];
2514 let excess_address_data = if addr_readpos < addr_len {
2515 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2516 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2518 excess_address_data[0] = excess_byte;
2523 excess_data.push(excess_byte);
2527 excess_data.extend(read_to_end(r)?.iter());
2528 Ok(UnsignedNodeAnnouncement {
2535 excess_address_data,
2541 impl_writeable!(NodeAnnouncement, {
2546 impl Readable for QueryShortChannelIds {
2547 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2548 let chain_hash: ChainHash = Readable::read(r)?;
2550 let encoding_len: u16 = Readable::read(r)?;
2551 let encoding_type: u8 = Readable::read(r)?;
2553 // Must be encoding_type=0 uncompressed serialization. We do not
2554 // support encoding_type=1 zlib serialization.
2555 if encoding_type != EncodingType::Uncompressed as u8 {
2556 return Err(DecodeError::UnsupportedCompression);
2559 // We expect the encoding_len to always includes the 1-byte
2560 // encoding_type and that short_channel_ids are 8-bytes each
2561 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2562 return Err(DecodeError::InvalidValue);
2565 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2566 // less the 1-byte encoding_type
2567 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2568 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2569 for _ in 0..short_channel_id_count {
2570 short_channel_ids.push(Readable::read(r)?);
2573 Ok(QueryShortChannelIds {
2580 impl Writeable for QueryShortChannelIds {
2581 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2582 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2583 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2585 self.chain_hash.write(w)?;
2586 encoding_len.write(w)?;
2588 // We only support type=0 uncompressed serialization
2589 (EncodingType::Uncompressed as u8).write(w)?;
2591 for scid in self.short_channel_ids.iter() {
2599 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2604 impl QueryChannelRange {
2605 /// Calculates the overflow safe ending block height for the query.
2607 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2608 pub fn end_blocknum(&self) -> u32 {
2609 match self.first_blocknum.checked_add(self.number_of_blocks) {
2610 Some(block) => block,
2611 None => u32::max_value(),
2616 impl_writeable_msg!(QueryChannelRange, {
2622 impl Readable for ReplyChannelRange {
2623 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2624 let chain_hash: ChainHash = Readable::read(r)?;
2625 let first_blocknum: u32 = Readable::read(r)?;
2626 let number_of_blocks: u32 = Readable::read(r)?;
2627 let sync_complete: bool = Readable::read(r)?;
2629 let encoding_len: u16 = Readable::read(r)?;
2630 let encoding_type: u8 = Readable::read(r)?;
2632 // Must be encoding_type=0 uncompressed serialization. We do not
2633 // support encoding_type=1 zlib serialization.
2634 if encoding_type != EncodingType::Uncompressed as u8 {
2635 return Err(DecodeError::UnsupportedCompression);
2638 // We expect the encoding_len to always includes the 1-byte
2639 // encoding_type and that short_channel_ids are 8-bytes each
2640 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2641 return Err(DecodeError::InvalidValue);
2644 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2645 // less the 1-byte encoding_type
2646 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2647 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2648 for _ in 0..short_channel_id_count {
2649 short_channel_ids.push(Readable::read(r)?);
2652 Ok(ReplyChannelRange {
2662 impl Writeable for ReplyChannelRange {
2663 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2664 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2665 self.chain_hash.write(w)?;
2666 self.first_blocknum.write(w)?;
2667 self.number_of_blocks.write(w)?;
2668 self.sync_complete.write(w)?;
2670 encoding_len.write(w)?;
2671 (EncodingType::Uncompressed as u8).write(w)?;
2672 for scid in self.short_channel_ids.iter() {
2680 impl_writeable_msg!(GossipTimestampFilter, {
2688 use std::convert::TryFrom;
2689 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2691 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2692 use crate::ln::ChannelId;
2693 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2694 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2695 use crate::ln::msgs::SocketAddress;
2696 use crate::routing::gossip::{NodeAlias, NodeId};
2697 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2698 use crate::util::test_utils;
2700 use bitcoin::hashes::hex::FromHex;
2701 use bitcoin::util::address::Address;
2702 use bitcoin::network::constants::Network;
2703 use bitcoin::blockdata::constants::ChainHash;
2704 use bitcoin::blockdata::script::Builder;
2705 use bitcoin::blockdata::opcodes;
2706 use bitcoin::hash_types::Txid;
2708 use bitcoin::secp256k1::{PublicKey,SecretKey};
2709 use bitcoin::secp256k1::{Secp256k1, Message};
2711 use crate::io::{self, Cursor};
2712 use crate::prelude::*;
2713 use core::str::FromStr;
2714 use crate::chain::transaction::OutPoint;
2716 #[cfg(feature = "std")]
2717 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2718 use crate::ln::msgs::SocketAddressParseError;
2721 fn encoding_channel_reestablish() {
2723 let secp_ctx = Secp256k1::new();
2724 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2727 let cr = msgs::ChannelReestablish {
2728 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]),
2729 next_local_commitment_number: 3,
2730 next_remote_commitment_number: 4,
2731 your_last_per_commitment_secret: [9;32],
2732 my_current_per_commitment_point: public_key,
2733 next_funding_txid: None,
2736 let encoded_value = cr.encode();
2740 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
2741 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2742 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2743 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
2744 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
2750 fn encoding_channel_reestablish_with_next_funding_txid() {
2752 let secp_ctx = Secp256k1::new();
2753 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2756 let cr = msgs::ChannelReestablish {
2757 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]),
2758 next_local_commitment_number: 3,
2759 next_remote_commitment_number: 4,
2760 your_last_per_commitment_secret: [9;32],
2761 my_current_per_commitment_point: public_key,
2762 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2763 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,
2767 let encoded_value = cr.encode();
2771 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
2772 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2773 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2774 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
2775 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
2776 0, // Type (next_funding_txid)
2778 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
2783 macro_rules! get_keys_from {
2784 ($slice: expr, $secp_ctx: expr) => {
2786 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2787 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2793 macro_rules! get_sig_on {
2794 ($privkey: expr, $ctx: expr, $string: expr) => {
2796 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2797 $ctx.sign_ecdsa(&sighash, &$privkey)
2803 fn encoding_announcement_signatures() {
2804 let secp_ctx = Secp256k1::new();
2805 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2806 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2807 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2808 let announcement_signatures = msgs::AnnouncementSignatures {
2809 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]),
2810 short_channel_id: 2316138423780173,
2811 node_signature: sig_1,
2812 bitcoin_signature: sig_2,
2815 let encoded_value = announcement_signatures.encode();
2816 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2819 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2820 let secp_ctx = Secp256k1::new();
2821 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2822 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2823 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2824 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2825 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2826 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2827 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2828 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2829 let mut features = ChannelFeatures::empty();
2830 if unknown_features_bits {
2831 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2833 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2835 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2836 short_channel_id: 2316138423780173,
2837 node_id_1: NodeId::from_pubkey(&pubkey_1),
2838 node_id_2: NodeId::from_pubkey(&pubkey_2),
2839 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2840 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2841 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2843 let channel_announcement = msgs::ChannelAnnouncement {
2844 node_signature_1: sig_1,
2845 node_signature_2: sig_2,
2846 bitcoin_signature_1: sig_3,
2847 bitcoin_signature_2: sig_4,
2848 contents: unsigned_channel_announcement,
2850 let encoded_value = channel_announcement.encode();
2851 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2852 if unknown_features_bits {
2853 target_value.append(&mut hex::decode("0002ffff").unwrap());
2855 target_value.append(&mut hex::decode("0000").unwrap());
2857 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
2858 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2860 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2862 assert_eq!(encoded_value, target_value);
2866 fn encoding_channel_announcement() {
2867 do_encoding_channel_announcement(true, false);
2868 do_encoding_channel_announcement(false, true);
2869 do_encoding_channel_announcement(false, false);
2870 do_encoding_channel_announcement(true, true);
2873 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) {
2874 let secp_ctx = Secp256k1::new();
2875 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2876 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2877 let features = if unknown_features_bits {
2878 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2880 // Set to some features we may support
2881 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2883 let mut addresses = Vec::new();
2885 addresses.push(SocketAddress::TcpIpV4 {
2886 addr: [255, 254, 253, 252],
2891 addresses.push(SocketAddress::TcpIpV6 {
2892 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2897 addresses.push(msgs::SocketAddress::OnionV2(
2898 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2902 addresses.push(msgs::SocketAddress::OnionV3 {
2903 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],
2910 addresses.push(SocketAddress::Hostname {
2911 hostname: Hostname::try_from(String::from("host")).unwrap(),
2915 let mut addr_len = 0;
2916 for addr in &addresses {
2917 addr_len += addr.len() + 1;
2919 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2921 timestamp: 20190119,
2922 node_id: NodeId::from_pubkey(&pubkey_1),
2924 alias: NodeAlias([16;32]),
2926 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() },
2927 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() },
2929 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2930 let node_announcement = msgs::NodeAnnouncement {
2932 contents: unsigned_node_announcement,
2934 let encoded_value = node_announcement.encode();
2935 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2936 if unknown_features_bits {
2937 target_value.append(&mut hex::decode("0002ffff").unwrap());
2939 target_value.append(&mut hex::decode("000122").unwrap());
2941 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2942 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2944 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2947 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2950 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2953 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2956 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2958 if excess_address_data {
2959 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2962 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2964 assert_eq!(encoded_value, target_value);
2968 fn encoding_node_announcement() {
2969 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2970 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2971 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2972 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2973 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2974 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2975 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2976 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2977 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2978 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2981 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2982 let secp_ctx = Secp256k1::new();
2983 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2984 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2985 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2986 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
2987 short_channel_id: 2316138423780173,
2988 timestamp: 20190119,
2989 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2990 cltv_expiry_delta: 144,
2991 htlc_minimum_msat: 1000000,
2992 htlc_maximum_msat: 131355275467161,
2993 fee_base_msat: 10000,
2994 fee_proportional_millionths: 20,
2995 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2997 let channel_update = msgs::ChannelUpdate {
2999 contents: unsigned_channel_update
3001 let encoded_value = channel_update.encode();
3002 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3003 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3004 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
3005 target_value.append(&mut hex::decode("01").unwrap());
3006 target_value.append(&mut hex::decode("00").unwrap());
3008 let flag = target_value.last_mut().unwrap();
3012 let flag = target_value.last_mut().unwrap();
3013 *flag = *flag | 1 << 1;
3015 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
3016 target_value.append(&mut hex::decode("0000777788889999").unwrap());
3018 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
3020 assert_eq!(encoded_value, target_value);
3024 fn encoding_channel_update() {
3025 do_encoding_channel_update(false, false, false);
3026 do_encoding_channel_update(false, false, true);
3027 do_encoding_channel_update(true, false, false);
3028 do_encoding_channel_update(true, false, true);
3029 do_encoding_channel_update(false, true, false);
3030 do_encoding_channel_update(false, true, true);
3031 do_encoding_channel_update(true, true, false);
3032 do_encoding_channel_update(true, true, true);
3035 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3036 let secp_ctx = Secp256k1::new();
3037 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3038 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3039 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3040 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3041 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3042 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3043 let open_channel = msgs::OpenChannel {
3044 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3045 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3046 funding_satoshis: 1311768467284833366,
3047 push_msat: 2536655962884945560,
3048 dust_limit_satoshis: 3608586615801332854,
3049 max_htlc_value_in_flight_msat: 8517154655701053848,
3050 channel_reserve_satoshis: 8665828695742877976,
3051 htlc_minimum_msat: 2316138423780173,
3052 feerate_per_kw: 821716,
3053 to_self_delay: 49340,
3054 max_accepted_htlcs: 49340,
3055 funding_pubkey: pubkey_1,
3056 revocation_basepoint: pubkey_2,
3057 payment_point: pubkey_3,
3058 delayed_payment_basepoint: pubkey_4,
3059 htlc_basepoint: pubkey_5,
3060 first_per_commitment_point: pubkey_6,
3061 channel_flags: if random_bit { 1 << 5 } else { 0 },
3062 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3063 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3065 let encoded_value = open_channel.encode();
3066 let mut target_value = Vec::new();
3067 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3068 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3070 target_value.append(&mut hex::decode("20").unwrap());
3072 target_value.append(&mut hex::decode("00").unwrap());
3075 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3078 target_value.append(&mut hex::decode("0100").unwrap());
3080 assert_eq!(encoded_value, target_value);
3084 fn encoding_open_channel() {
3085 do_encoding_open_channel(false, false, false);
3086 do_encoding_open_channel(false, false, true);
3087 do_encoding_open_channel(false, true, false);
3088 do_encoding_open_channel(false, true, true);
3089 do_encoding_open_channel(true, false, false);
3090 do_encoding_open_channel(true, false, true);
3091 do_encoding_open_channel(true, true, false);
3092 do_encoding_open_channel(true, true, true);
3095 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3096 let secp_ctx = Secp256k1::new();
3097 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3098 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3099 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3100 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3101 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3102 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3103 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3104 let open_channelv2 = msgs::OpenChannelV2 {
3105 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3106 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3107 funding_feerate_sat_per_1000_weight: 821716,
3108 commitment_feerate_sat_per_1000_weight: 821716,
3109 funding_satoshis: 1311768467284833366,
3110 dust_limit_satoshis: 3608586615801332854,
3111 max_htlc_value_in_flight_msat: 8517154655701053848,
3112 htlc_minimum_msat: 2316138423780173,
3113 to_self_delay: 49340,
3114 max_accepted_htlcs: 49340,
3115 locktime: 305419896,
3116 funding_pubkey: pubkey_1,
3117 revocation_basepoint: pubkey_2,
3118 payment_basepoint: pubkey_3,
3119 delayed_payment_basepoint: pubkey_4,
3120 htlc_basepoint: pubkey_5,
3121 first_per_commitment_point: pubkey_6,
3122 second_per_commitment_point: pubkey_7,
3123 channel_flags: if random_bit { 1 << 5 } else { 0 },
3124 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3125 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3126 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3128 let encoded_value = open_channelv2.encode();
3129 let mut target_value = Vec::new();
3130 target_value.append(&mut hex::decode("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3131 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3132 target_value.append(&mut hex::decode("000c89d4").unwrap());
3133 target_value.append(&mut hex::decode("000c89d4").unwrap());
3134 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3135 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3136 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3137 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3138 target_value.append(&mut hex::decode("c0bc").unwrap());
3139 target_value.append(&mut hex::decode("c0bc").unwrap());
3140 target_value.append(&mut hex::decode("12345678").unwrap());
3141 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3142 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3143 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3144 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3145 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3146 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3147 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3150 target_value.append(&mut hex::decode("20").unwrap());
3152 target_value.append(&mut hex::decode("00").unwrap());
3155 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3156 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3159 target_value.append(&mut hex::decode("0100").unwrap());
3161 if require_confirmed_inputs {
3162 target_value.append(&mut hex::decode("0200").unwrap());
3164 assert_eq!(encoded_value, target_value);
3168 fn encoding_open_channelv2() {
3169 do_encoding_open_channelv2(false, false, false, false);
3170 do_encoding_open_channelv2(false, false, false, true);
3171 do_encoding_open_channelv2(false, false, true, false);
3172 do_encoding_open_channelv2(false, false, true, true);
3173 do_encoding_open_channelv2(false, true, false, false);
3174 do_encoding_open_channelv2(false, true, false, true);
3175 do_encoding_open_channelv2(false, true, true, false);
3176 do_encoding_open_channelv2(false, true, true, true);
3177 do_encoding_open_channelv2(true, false, false, false);
3178 do_encoding_open_channelv2(true, false, false, true);
3179 do_encoding_open_channelv2(true, false, true, false);
3180 do_encoding_open_channelv2(true, false, true, true);
3181 do_encoding_open_channelv2(true, true, false, false);
3182 do_encoding_open_channelv2(true, true, false, true);
3183 do_encoding_open_channelv2(true, true, true, false);
3184 do_encoding_open_channelv2(true, true, true, true);
3187 fn do_encoding_accept_channel(shutdown: bool) {
3188 let secp_ctx = Secp256k1::new();
3189 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3190 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3191 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3192 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3193 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3194 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3195 let accept_channel = msgs::AcceptChannel {
3196 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3197 dust_limit_satoshis: 1311768467284833366,
3198 max_htlc_value_in_flight_msat: 2536655962884945560,
3199 channel_reserve_satoshis: 3608586615801332854,
3200 htlc_minimum_msat: 2316138423780173,
3201 minimum_depth: 821716,
3202 to_self_delay: 49340,
3203 max_accepted_htlcs: 49340,
3204 funding_pubkey: pubkey_1,
3205 revocation_basepoint: pubkey_2,
3206 payment_point: pubkey_3,
3207 delayed_payment_basepoint: pubkey_4,
3208 htlc_basepoint: pubkey_5,
3209 first_per_commitment_point: pubkey_6,
3210 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3213 next_local_nonce: None,
3215 let encoded_value = accept_channel.encode();
3216 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3218 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3220 assert_eq!(encoded_value, target_value);
3224 fn encoding_accept_channel() {
3225 do_encoding_accept_channel(false);
3226 do_encoding_accept_channel(true);
3229 fn do_encoding_accept_channelv2(shutdown: bool) {
3230 let secp_ctx = Secp256k1::new();
3231 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3232 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3233 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3234 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3235 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3236 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3237 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3238 let accept_channelv2 = msgs::AcceptChannelV2 {
3239 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3240 funding_satoshis: 1311768467284833366,
3241 dust_limit_satoshis: 1311768467284833366,
3242 max_htlc_value_in_flight_msat: 2536655962884945560,
3243 htlc_minimum_msat: 2316138423780173,
3244 minimum_depth: 821716,
3245 to_self_delay: 49340,
3246 max_accepted_htlcs: 49340,
3247 funding_pubkey: pubkey_1,
3248 revocation_basepoint: pubkey_2,
3249 payment_basepoint: pubkey_3,
3250 delayed_payment_basepoint: pubkey_4,
3251 htlc_basepoint: pubkey_5,
3252 first_per_commitment_point: pubkey_6,
3253 second_per_commitment_point: pubkey_7,
3254 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3256 require_confirmed_inputs: None,
3258 let encoded_value = accept_channelv2.encode();
3259 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3260 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3261 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3262 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3263 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3264 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3265 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3266 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3267 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3268 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3269 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3270 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3271 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3272 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3273 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3275 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3276 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3278 assert_eq!(encoded_value, target_value);
3282 fn encoding_accept_channelv2() {
3283 do_encoding_accept_channelv2(false);
3284 do_encoding_accept_channelv2(true);
3288 fn encoding_funding_created() {
3289 let secp_ctx = Secp256k1::new();
3290 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3291 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3292 let funding_created = msgs::FundingCreated {
3293 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3294 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3295 funding_output_index: 255,
3298 partial_signature_with_nonce: None,
3300 next_local_nonce: None,
3302 let encoded_value = funding_created.encode();
3303 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3304 assert_eq!(encoded_value, target_value);
3308 fn encoding_funding_signed() {
3309 let secp_ctx = Secp256k1::new();
3310 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3311 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3312 let funding_signed = msgs::FundingSigned {
3313 channel_id: ChannelId::from_bytes([2; 32]),
3316 partial_signature_with_nonce: None,
3318 let encoded_value = funding_signed.encode();
3319 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3320 assert_eq!(encoded_value, target_value);
3324 fn encoding_channel_ready() {
3325 let secp_ctx = Secp256k1::new();
3326 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3327 let channel_ready = msgs::ChannelReady {
3328 channel_id: ChannelId::from_bytes([2; 32]),
3329 next_per_commitment_point: pubkey_1,
3330 short_channel_id_alias: None,
3332 let encoded_value = channel_ready.encode();
3333 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3334 assert_eq!(encoded_value, target_value);
3338 fn encoding_tx_add_input() {
3339 let tx_add_input = msgs::TxAddInput {
3340 channel_id: ChannelId::from_bytes([2; 32]),
3341 serial_id: 4886718345,
3342 prevtx: TransactionU16LenLimited::new(Transaction {
3344 lock_time: PackedLockTime(0),
3346 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3347 script_sig: Script::new(),
3348 sequence: Sequence(0xfffffffd),
3349 witness: Witness::from_vec(vec![
3350 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3351 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3356 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3360 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3364 prevtx_out: 305419896,
3365 sequence: 305419896,
3367 let encoded_value = tx_add_input.encode();
3368 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3369 assert_eq!(encoded_value, target_value);
3373 fn encoding_tx_add_output() {
3374 let tx_add_output = msgs::TxAddOutput {
3375 channel_id: ChannelId::from_bytes([2; 32]),
3376 serial_id: 4886718345,
3378 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3380 let encoded_value = tx_add_output.encode();
3381 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3382 assert_eq!(encoded_value, target_value);
3386 fn encoding_tx_remove_input() {
3387 let tx_remove_input = msgs::TxRemoveInput {
3388 channel_id: ChannelId::from_bytes([2; 32]),
3389 serial_id: 4886718345,
3391 let encoded_value = tx_remove_input.encode();
3392 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3393 assert_eq!(encoded_value, target_value);
3397 fn encoding_tx_remove_output() {
3398 let tx_remove_output = msgs::TxRemoveOutput {
3399 channel_id: ChannelId::from_bytes([2; 32]),
3400 serial_id: 4886718345,
3402 let encoded_value = tx_remove_output.encode();
3403 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3404 assert_eq!(encoded_value, target_value);
3408 fn encoding_tx_complete() {
3409 let tx_complete = msgs::TxComplete {
3410 channel_id: ChannelId::from_bytes([2; 32]),
3412 let encoded_value = tx_complete.encode();
3413 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3414 assert_eq!(encoded_value, target_value);
3418 fn encoding_tx_signatures() {
3419 let tx_signatures = msgs::TxSignatures {
3420 channel_id: ChannelId::from_bytes([2; 32]),
3421 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3423 Witness::from_vec(vec![
3424 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3425 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3426 Witness::from_vec(vec![
3427 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3428 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3431 let encoded_value = tx_signatures.encode();
3432 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3433 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3434 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3436 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3437 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3438 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3439 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3440 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3441 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3443 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3444 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3445 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3446 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3447 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3448 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3449 assert_eq!(encoded_value, target_value);
3452 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3453 let tx_init_rbf = msgs::TxInitRbf {
3454 channel_id: ChannelId::from_bytes([2; 32]),
3455 locktime: 305419896,
3456 feerate_sat_per_1000_weight: 20190119,
3457 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3459 let encoded_value = tx_init_rbf.encode();
3460 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3461 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3462 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3463 if let Some((_, target)) = funding_value_with_hex_target {
3464 target_value.push(0x00); // Type
3465 target_value.push(target.len() as u8 / 2); // Length
3466 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3468 assert_eq!(encoded_value, target_value);
3472 fn encoding_tx_init_rbf() {
3473 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3474 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3475 do_encoding_tx_init_rbf(None);
3478 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3479 let tx_ack_rbf = msgs::TxAckRbf {
3480 channel_id: ChannelId::from_bytes([2; 32]),
3481 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3483 let encoded_value = tx_ack_rbf.encode();
3484 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3485 if let Some((_, target)) = funding_value_with_hex_target {
3486 target_value.push(0x00); // Type
3487 target_value.push(target.len() as u8 / 2); // Length
3488 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3490 assert_eq!(encoded_value, target_value);
3494 fn encoding_tx_ack_rbf() {
3495 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3496 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3497 do_encoding_tx_ack_rbf(None);
3501 fn encoding_tx_abort() {
3502 let tx_abort = msgs::TxAbort {
3503 channel_id: ChannelId::from_bytes([2; 32]),
3504 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3506 let encoded_value = tx_abort.encode();
3507 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3508 assert_eq!(encoded_value, target_value);
3511 fn do_encoding_shutdown(script_type: u8) {
3512 let secp_ctx = Secp256k1::new();
3513 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3514 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3515 let shutdown = msgs::Shutdown {
3516 channel_id: ChannelId::from_bytes([2; 32]),
3518 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3519 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3520 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3521 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3523 let encoded_value = shutdown.encode();
3524 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3525 if script_type == 1 {
3526 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3527 } else if script_type == 2 {
3528 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3529 } else if script_type == 3 {
3530 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3531 } else if script_type == 4 {
3532 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3534 assert_eq!(encoded_value, target_value);
3538 fn encoding_shutdown() {
3539 do_encoding_shutdown(1);
3540 do_encoding_shutdown(2);
3541 do_encoding_shutdown(3);
3542 do_encoding_shutdown(4);
3546 fn encoding_closing_signed() {
3547 let secp_ctx = Secp256k1::new();
3548 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3549 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3550 let closing_signed = msgs::ClosingSigned {
3551 channel_id: ChannelId::from_bytes([2; 32]),
3552 fee_satoshis: 2316138423780173,
3556 let encoded_value = closing_signed.encode();
3557 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3558 assert_eq!(encoded_value, target_value);
3559 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3561 let closing_signed_with_range = msgs::ClosingSigned {
3562 channel_id: ChannelId::from_bytes([2; 32]),
3563 fee_satoshis: 2316138423780173,
3565 fee_range: Some(msgs::ClosingSignedFeeRange {
3566 min_fee_satoshis: 0xdeadbeef,
3567 max_fee_satoshis: 0x1badcafe01234567,
3570 let encoded_value_with_range = closing_signed_with_range.encode();
3571 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3572 assert_eq!(encoded_value_with_range, target_value_with_range);
3573 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3574 closing_signed_with_range);
3578 fn encoding_update_add_htlc() {
3579 let secp_ctx = Secp256k1::new();
3580 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3581 let onion_routing_packet = msgs::OnionPacket {
3583 public_key: Ok(pubkey_1),
3584 hop_data: [1; 20*65],
3587 let update_add_htlc = msgs::UpdateAddHTLC {
3588 channel_id: ChannelId::from_bytes([2; 32]),
3589 htlc_id: 2316138423780173,
3590 amount_msat: 3608586615801332854,
3591 payment_hash: PaymentHash([1; 32]),
3592 cltv_expiry: 821716,
3593 onion_routing_packet,
3594 skimmed_fee_msat: None,
3596 let encoded_value = update_add_htlc.encode();
3597 let target_value = hex::decode("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").unwrap();
3598 assert_eq!(encoded_value, target_value);
3602 fn encoding_update_fulfill_htlc() {
3603 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3604 channel_id: ChannelId::from_bytes([2; 32]),
3605 htlc_id: 2316138423780173,
3606 payment_preimage: PaymentPreimage([1; 32]),
3608 let encoded_value = update_fulfill_htlc.encode();
3609 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3610 assert_eq!(encoded_value, target_value);
3614 fn encoding_update_fail_htlc() {
3615 let reason = OnionErrorPacket {
3616 data: [1; 32].to_vec(),
3618 let update_fail_htlc = msgs::UpdateFailHTLC {
3619 channel_id: ChannelId::from_bytes([2; 32]),
3620 htlc_id: 2316138423780173,
3623 let encoded_value = update_fail_htlc.encode();
3624 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3625 assert_eq!(encoded_value, target_value);
3629 fn encoding_update_fail_malformed_htlc() {
3630 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3631 channel_id: ChannelId::from_bytes([2; 32]),
3632 htlc_id: 2316138423780173,
3633 sha256_of_onion: [1; 32],
3636 let encoded_value = update_fail_malformed_htlc.encode();
3637 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3638 assert_eq!(encoded_value, target_value);
3641 fn do_encoding_commitment_signed(htlcs: bool) {
3642 let secp_ctx = Secp256k1::new();
3643 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3644 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3645 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3646 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3647 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3648 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3649 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3650 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3651 let commitment_signed = msgs::CommitmentSigned {
3652 channel_id: ChannelId::from_bytes([2; 32]),
3654 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3656 partial_signature_with_nonce: None,
3658 let encoded_value = commitment_signed.encode();
3659 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3661 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3663 target_value.append(&mut hex::decode("0000").unwrap());
3665 assert_eq!(encoded_value, target_value);
3669 fn encoding_commitment_signed() {
3670 do_encoding_commitment_signed(true);
3671 do_encoding_commitment_signed(false);
3675 fn encoding_revoke_and_ack() {
3676 let secp_ctx = Secp256k1::new();
3677 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3678 let raa = msgs::RevokeAndACK {
3679 channel_id: ChannelId::from_bytes([2; 32]),
3680 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],
3681 next_per_commitment_point: pubkey_1,
3683 next_local_nonce: None,
3685 let encoded_value = raa.encode();
3686 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3687 assert_eq!(encoded_value, target_value);
3691 fn encoding_update_fee() {
3692 let update_fee = msgs::UpdateFee {
3693 channel_id: ChannelId::from_bytes([2; 32]),
3694 feerate_per_kw: 20190119,
3696 let encoded_value = update_fee.encode();
3697 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3698 assert_eq!(encoded_value, target_value);
3702 fn encoding_init() {
3703 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
3704 assert_eq!(msgs::Init {
3705 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3706 networks: Some(vec![mainnet_hash]),
3707 remote_network_address: None,
3708 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3709 assert_eq!(msgs::Init {
3710 features: InitFeatures::from_le_bytes(vec![0xFF]),
3712 remote_network_address: None,
3713 }.encode(), hex::decode("0001ff0001ff").unwrap());
3714 assert_eq!(msgs::Init {
3715 features: InitFeatures::from_le_bytes(vec![]),
3716 networks: Some(vec![mainnet_hash]),
3717 remote_network_address: None,
3718 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3719 assert_eq!(msgs::Init {
3720 features: InitFeatures::from_le_bytes(vec![]),
3721 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3722 remote_network_address: None,
3723 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3724 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3725 networks: Some(vec![mainnet_hash]),
3726 remote_network_address: Some(SocketAddress::TcpIpV4 {
3727 addr: [127, 0, 0, 1],
3731 let encoded_value = init_msg.encode();
3732 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3733 assert_eq!(encoded_value, target_value);
3734 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3738 fn encoding_error() {
3739 let error = msgs::ErrorMessage {
3740 channel_id: ChannelId::from_bytes([2; 32]),
3741 data: String::from("rust-lightning"),
3743 let encoded_value = error.encode();
3744 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3745 assert_eq!(encoded_value, target_value);
3749 fn encoding_warning() {
3750 let error = msgs::WarningMessage {
3751 channel_id: ChannelId::from_bytes([2; 32]),
3752 data: String::from("rust-lightning"),
3754 let encoded_value = error.encode();
3755 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3756 assert_eq!(encoded_value, target_value);
3760 fn encoding_ping() {
3761 let ping = msgs::Ping {
3765 let encoded_value = ping.encode();
3766 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3767 assert_eq!(encoded_value, target_value);
3771 fn encoding_pong() {
3772 let pong = msgs::Pong {
3775 let encoded_value = pong.encode();
3776 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3777 assert_eq!(encoded_value, target_value);
3781 fn encoding_nonfinal_onion_hop_data() {
3782 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3783 short_channel_id: 0xdeadbeef1bad1dea,
3784 amt_to_forward: 0x0badf00d01020304,
3785 outgoing_cltv_value: 0xffffffff,
3787 let encoded_value = outbound_msg.encode();
3788 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3789 assert_eq!(encoded_value, target_value);
3791 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3792 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3793 if let msgs::InboundOnionPayload::Forward {
3794 short_channel_id, amt_to_forward, outgoing_cltv_value
3796 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3797 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3798 assert_eq!(outgoing_cltv_value, 0xffffffff);
3799 } else { panic!(); }
3803 fn encoding_final_onion_hop_data() {
3804 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3806 payment_metadata: None,
3807 keysend_preimage: None,
3808 amt_msat: 0x0badf00d01020304,
3809 outgoing_cltv_value: 0xffffffff,
3810 custom_tlvs: vec![],
3812 let encoded_value = outbound_msg.encode();
3813 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3814 assert_eq!(encoded_value, target_value);
3816 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3817 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3818 if let msgs::InboundOnionPayload::Receive {
3819 payment_data: None, amt_msat, outgoing_cltv_value, ..
3821 assert_eq!(amt_msat, 0x0badf00d01020304);
3822 assert_eq!(outgoing_cltv_value, 0xffffffff);
3823 } else { panic!(); }
3827 fn encoding_final_onion_hop_data_with_secret() {
3828 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3829 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3830 payment_data: Some(FinalOnionHopData {
3831 payment_secret: expected_payment_secret,
3832 total_msat: 0x1badca1f
3834 payment_metadata: None,
3835 keysend_preimage: None,
3836 amt_msat: 0x0badf00d01020304,
3837 outgoing_cltv_value: 0xffffffff,
3838 custom_tlvs: vec![],
3840 let encoded_value = outbound_msg.encode();
3841 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3842 assert_eq!(encoded_value, target_value);
3844 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3845 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3846 if let msgs::InboundOnionPayload::Receive {
3847 payment_data: Some(FinalOnionHopData {
3849 total_msat: 0x1badca1f
3851 amt_msat, outgoing_cltv_value,
3852 payment_metadata: None,
3853 keysend_preimage: None,
3856 assert_eq!(payment_secret, expected_payment_secret);
3857 assert_eq!(amt_msat, 0x0badf00d01020304);
3858 assert_eq!(outgoing_cltv_value, 0xffffffff);
3859 assert_eq!(custom_tlvs, vec![]);
3860 } else { panic!(); }
3864 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3865 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3867 let bad_type_range_tlvs = vec![
3868 ((1 << 16) - 4, vec![42]),
3869 ((1 << 16) - 2, vec![42; 32]),
3871 let mut msg = msgs::OutboundOnionPayload::Receive {
3873 payment_metadata: None,
3874 keysend_preimage: None,
3875 custom_tlvs: bad_type_range_tlvs,
3876 amt_msat: 0x0badf00d01020304,
3877 outgoing_cltv_value: 0xffffffff,
3879 let encoded_value = msg.encode();
3880 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3881 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
3882 let good_type_range_tlvs = vec![
3883 ((1 << 16) - 3, vec![42]),
3884 ((1 << 16) - 1, vec![42; 32]),
3886 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3887 *custom_tlvs = good_type_range_tlvs.clone();
3889 let encoded_value = msg.encode();
3890 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
3892 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3898 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3899 let expected_custom_tlvs = vec![
3900 (5482373483, vec![0x12, 0x34]),
3901 (5482373487, vec![0x42u8; 8]),
3903 let msg = msgs::OutboundOnionPayload::Receive {
3905 payment_metadata: None,
3906 keysend_preimage: None,
3907 custom_tlvs: expected_custom_tlvs.clone(),
3908 amt_msat: 0x0badf00d01020304,
3909 outgoing_cltv_value: 0xffffffff,
3911 let encoded_value = msg.encode();
3912 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3913 assert_eq!(encoded_value, target_value);
3914 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3915 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3916 if let msgs::InboundOnionPayload::Receive {
3918 payment_metadata: None,
3919 keysend_preimage: None,
3922 outgoing_cltv_value,
3925 assert_eq!(custom_tlvs, expected_custom_tlvs);
3926 assert_eq!(amt_msat, 0x0badf00d01020304);
3927 assert_eq!(outgoing_cltv_value, 0xffffffff);
3928 } else { panic!(); }
3932 fn query_channel_range_end_blocknum() {
3933 let tests: Vec<(u32, u32, u32)> = vec![
3934 (10000, 1500, 11500),
3935 (0, 0xffffffff, 0xffffffff),
3936 (1, 0xffffffff, 0xffffffff),
3939 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3940 let sut = msgs::QueryChannelRange {
3941 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3945 assert_eq!(sut.end_blocknum(), expected);
3950 fn encoding_query_channel_range() {
3951 let mut query_channel_range = msgs::QueryChannelRange {
3952 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
3953 first_blocknum: 100000,
3954 number_of_blocks: 1500,
3956 let encoded_value = query_channel_range.encode();
3957 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
3958 assert_eq!(encoded_value, target_value);
3960 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3961 assert_eq!(query_channel_range.first_blocknum, 100000);
3962 assert_eq!(query_channel_range.number_of_blocks, 1500);
3966 fn encoding_reply_channel_range() {
3967 do_encoding_reply_channel_range(0);
3968 do_encoding_reply_channel_range(1);
3971 fn do_encoding_reply_channel_range(encoding_type: u8) {
3972 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
3973 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
3974 let mut reply_channel_range = msgs::ReplyChannelRange {
3975 chain_hash: expected_chain_hash,
3976 first_blocknum: 756230,
3977 number_of_blocks: 1500,
3978 sync_complete: true,
3979 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3982 if encoding_type == 0 {
3983 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3984 let encoded_value = reply_channel_range.encode();
3985 assert_eq!(encoded_value, target_value);
3987 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3988 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3989 assert_eq!(reply_channel_range.first_blocknum, 756230);
3990 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3991 assert_eq!(reply_channel_range.sync_complete, true);
3992 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3993 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3994 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3996 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3997 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3998 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4003 fn encoding_query_short_channel_ids() {
4004 do_encoding_query_short_channel_ids(0);
4005 do_encoding_query_short_channel_ids(1);
4008 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4009 let mut target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4010 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4011 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4012 chain_hash: expected_chain_hash,
4013 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4016 if encoding_type == 0 {
4017 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4018 let encoded_value = query_short_channel_ids.encode();
4019 assert_eq!(encoded_value, target_value);
4021 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4022 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4023 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4024 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4025 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4027 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4028 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4029 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4034 fn encoding_reply_short_channel_ids_end() {
4035 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4036 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4037 chain_hash: expected_chain_hash,
4038 full_information: true,
4040 let encoded_value = reply_short_channel_ids_end.encode();
4041 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4042 assert_eq!(encoded_value, target_value);
4044 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4045 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4046 assert_eq!(reply_short_channel_ids_end.full_information, true);
4050 fn encoding_gossip_timestamp_filter(){
4051 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4052 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4053 chain_hash: expected_chain_hash,
4054 first_timestamp: 1590000000,
4055 timestamp_range: 0xffff_ffff,
4057 let encoded_value = gossip_timestamp_filter.encode();
4058 let target_value = hex::decode("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4059 assert_eq!(encoded_value, target_value);
4061 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4062 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4063 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4064 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4068 fn decode_onion_hop_data_len_as_bigsize() {
4069 // Tests that we can decode an onion payload that is >253 bytes.
4070 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4071 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4074 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4075 // payload length to be encoded over multiple bytes rather than a single u8.
4076 let big_payload = encode_big_payload().unwrap();
4077 let mut rd = Cursor::new(&big_payload[..]);
4079 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4080 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4081 ::read(&mut rd, &&node_signer).unwrap();
4083 // see above test, needs to be a separate method for use of the serialization macros.
4084 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4085 use crate::util::ser::HighZeroBytesDroppedBigSize;
4086 let payload = msgs::OutboundOnionPayload::Forward {
4087 short_channel_id: 0xdeadbeef1bad1dea,
4088 amt_to_forward: 1000,
4089 outgoing_cltv_value: 0xffffffff,
4091 let mut encoded_payload = Vec::new();
4092 let test_bytes = vec![42u8; 1000];
4093 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4094 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4095 (1, test_bytes, required_vec),
4096 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4097 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4098 (6, short_channel_id, required)
4105 #[cfg(feature = "std")]
4106 fn test_socket_address_from_str() {
4107 assert_eq!(SocketAddress::TcpIpV4 {
4108 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4110 }, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4112 assert_eq!(SocketAddress::TcpIpV6 {
4113 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4115 }, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4117 SocketAddress::Hostname {
4118 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4120 }, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4122 SocketAddress::Hostname {
4123 hostname: Hostname::try_from("example.com".to_string()).unwrap(),
4125 }, SocketAddress::from_str("example.com:1234").unwrap());
4126 assert_eq!(SocketAddress::OnionV3 {
4127 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4128 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4132 }, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4133 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4134 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4135 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4136 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4137 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4138 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4139 assert!("localhost".parse::<SocketAddress>().is_err());
4140 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4141 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4142 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4143 assert!("invalid-address".parse::<SocketAddress>().is_err());
4144 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4148 #[cfg(feature = "std")]
4149 fn test_socket_address_to_socket_addrs() {
4150 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4151 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4152 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4153 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4154 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4155 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4156 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4157 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4158 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4162 port: 1234 }.to_socket_addrs().is_err());