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, BlockHash};
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, OnionMessageProvider};
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: BlockHash,
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: BlockHash,
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: BlockHash,
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: BlockHash,
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: BlockHash,
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: BlockHash,
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: BlockHash,
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: BlockHash,
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: BlockHash,
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 genesis 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_genesis_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 trait to describe an object that can receive onion messages.
1534 pub trait OnionMessageHandler : OnionMessageProvider {
1535 /// Handle an incoming `onion_message` message from the given peer.
1536 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1537 /// Called when a connection is established with a peer. Can be used to track which peers
1538 /// advertise onion message support and are online.
1540 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1541 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1542 /// message handlers may still wish to communicate with this peer.
1543 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1544 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1545 /// drop and refuse to forward onion messages to this peer.
1546 fn peer_disconnected(&self, their_node_id: &PublicKey);
1548 // Handler information:
1549 /// Gets the node feature flags which this handler itself supports. All available handlers are
1550 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1551 /// which are broadcasted in our [`NodeAnnouncement`] message.
1552 fn provided_node_features(&self) -> NodeFeatures;
1554 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1555 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1556 /// which are sent in our [`Init`] message.
1558 /// Note that this method is called before [`Self::peer_connected`].
1559 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1562 mod fuzzy_internal_msgs {
1563 use bitcoin::secp256k1::PublicKey;
1564 use crate::blinded_path::payment::PaymentConstraints;
1565 use crate::prelude::*;
1566 use crate::ln::{PaymentPreimage, PaymentSecret};
1568 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1569 // them from untrusted input):
1571 pub struct FinalOnionHopData {
1572 pub payment_secret: PaymentSecret,
1573 /// The total value, in msat, of the payment as received by the ultimate recipient.
1574 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1575 pub total_msat: u64,
1578 pub enum InboundOnionPayload {
1580 short_channel_id: u64,
1581 /// The value, in msat, of the payment after this hop's fee is deducted.
1582 amt_to_forward: u64,
1583 outgoing_cltv_value: u32,
1586 payment_data: Option<FinalOnionHopData>,
1587 payment_metadata: Option<Vec<u8>>,
1588 keysend_preimage: Option<PaymentPreimage>,
1589 custom_tlvs: Vec<(u64, Vec<u8>)>,
1591 outgoing_cltv_value: u32,
1596 outgoing_cltv_value: u32,
1597 payment_secret: PaymentSecret,
1598 payment_constraints: PaymentConstraints,
1599 intro_node_blinding_point: PublicKey,
1603 pub(crate) enum OutboundOnionPayload {
1605 short_channel_id: u64,
1606 /// The value, in msat, of the payment after this hop's fee is deducted.
1607 amt_to_forward: u64,
1608 outgoing_cltv_value: u32,
1611 payment_data: Option<FinalOnionHopData>,
1612 payment_metadata: Option<Vec<u8>>,
1613 keysend_preimage: Option<PaymentPreimage>,
1614 custom_tlvs: Vec<(u64, Vec<u8>)>,
1616 outgoing_cltv_value: u32,
1619 encrypted_tlvs: Vec<u8>,
1620 intro_node_blinding_point: Option<PublicKey>,
1625 outgoing_cltv_value: u32,
1626 encrypted_tlvs: Vec<u8>,
1627 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1631 pub struct DecodedOnionErrorPacket {
1632 pub(crate) hmac: [u8; 32],
1633 pub(crate) failuremsg: Vec<u8>,
1634 pub(crate) pad: Vec<u8>,
1638 pub use self::fuzzy_internal_msgs::*;
1639 #[cfg(not(fuzzing))]
1640 pub(crate) use self::fuzzy_internal_msgs::*;
1643 pub(crate) struct OnionPacket {
1644 pub(crate) version: u8,
1645 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1646 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1647 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1648 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1650 pub(crate) public_key: Result<PublicKey, secp256k1::Error>,
1651 pub(crate) hop_data: [u8; 20*65],
1652 pub(crate) hmac: [u8; 32],
1655 impl onion_utils::Packet for OnionPacket {
1656 type Data = onion_utils::FixedSizeOnionPacket;
1657 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1660 public_key: Ok(pubkey),
1661 hop_data: hop_data.0,
1667 impl Eq for OnionPacket { }
1668 impl PartialEq for OnionPacket {
1669 fn eq(&self, other: &OnionPacket) -> bool {
1670 for (i, j) in self.hop_data.iter().zip(other.hop_data.iter()) {
1671 if i != j { return false; }
1673 self.version == other.version &&
1674 self.public_key == other.public_key &&
1675 self.hmac == other.hmac
1679 impl fmt::Debug for OnionPacket {
1680 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1681 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1685 #[derive(Clone, Debug, PartialEq, Eq)]
1686 pub(crate) struct OnionErrorPacket {
1687 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1688 // (TODO) We limit it in decode to much lower...
1689 pub(crate) data: Vec<u8>,
1692 impl fmt::Display for DecodeError {
1693 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1695 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1696 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1697 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1698 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1699 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1700 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1701 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1706 impl From<io::Error> for DecodeError {
1707 fn from(e: io::Error) -> Self {
1708 if e.kind() == io::ErrorKind::UnexpectedEof {
1709 DecodeError::ShortRead
1711 DecodeError::Io(e.kind())
1716 #[cfg(not(taproot))]
1717 impl_writeable_msg!(AcceptChannel, {
1718 temporary_channel_id,
1719 dust_limit_satoshis,
1720 max_htlc_value_in_flight_msat,
1721 channel_reserve_satoshis,
1727 revocation_basepoint,
1729 delayed_payment_basepoint,
1731 first_per_commitment_point,
1733 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1734 (1, channel_type, option),
1738 impl_writeable_msg!(AcceptChannel, {
1739 temporary_channel_id,
1740 dust_limit_satoshis,
1741 max_htlc_value_in_flight_msat,
1742 channel_reserve_satoshis,
1748 revocation_basepoint,
1750 delayed_payment_basepoint,
1752 first_per_commitment_point,
1754 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1755 (1, channel_type, option),
1756 (4, next_local_nonce, option),
1759 impl_writeable_msg!(AcceptChannelV2, {
1760 temporary_channel_id,
1762 dust_limit_satoshis,
1763 max_htlc_value_in_flight_msat,
1769 revocation_basepoint,
1771 delayed_payment_basepoint,
1773 first_per_commitment_point,
1774 second_per_commitment_point,
1776 (0, shutdown_scriptpubkey, option),
1777 (1, channel_type, option),
1778 (2, require_confirmed_inputs, option),
1781 impl_writeable_msg!(TxAddInput, {
1789 impl_writeable_msg!(TxAddOutput, {
1796 impl_writeable_msg!(TxRemoveInput, {
1801 impl_writeable_msg!(TxRemoveOutput, {
1806 impl_writeable_msg!(TxComplete, {
1810 impl_writeable_msg!(TxSignatures, {
1816 impl_writeable_msg!(TxInitRbf, {
1819 feerate_sat_per_1000_weight,
1821 (0, funding_output_contribution, option),
1824 impl_writeable_msg!(TxAckRbf, {
1827 (0, funding_output_contribution, option),
1830 impl_writeable_msg!(TxAbort, {
1835 impl_writeable_msg!(AnnouncementSignatures, {
1842 impl_writeable_msg!(ChannelReestablish, {
1844 next_local_commitment_number,
1845 next_remote_commitment_number,
1846 your_last_per_commitment_secret,
1847 my_current_per_commitment_point,
1849 (0, next_funding_txid, option),
1852 impl_writeable_msg!(ClosingSigned,
1853 { channel_id, fee_satoshis, signature },
1854 { (1, fee_range, option) }
1857 impl_writeable!(ClosingSignedFeeRange, {
1862 #[cfg(not(taproot))]
1863 impl_writeable_msg!(CommitmentSigned, {
1870 impl_writeable_msg!(CommitmentSigned, {
1875 (2, partial_signature_with_nonce, option)
1878 impl_writeable!(DecodedOnionErrorPacket, {
1884 #[cfg(not(taproot))]
1885 impl_writeable_msg!(FundingCreated, {
1886 temporary_channel_id,
1888 funding_output_index,
1892 impl_writeable_msg!(FundingCreated, {
1893 temporary_channel_id,
1895 funding_output_index,
1898 (2, partial_signature_with_nonce, option),
1899 (4, next_local_nonce, option)
1902 #[cfg(not(taproot))]
1903 impl_writeable_msg!(FundingSigned, {
1909 impl_writeable_msg!(FundingSigned, {
1913 (2, partial_signature_with_nonce, option)
1916 impl_writeable_msg!(ChannelReady, {
1918 next_per_commitment_point,
1920 (1, short_channel_id_alias, option),
1923 impl Writeable for Init {
1924 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1925 // global_features gets the bottom 13 bits of our features, and local_features gets all of
1926 // our relevant feature bits. This keeps us compatible with old nodes.
1927 self.features.write_up_to_13(w)?;
1928 self.features.write(w)?;
1929 encode_tlv_stream!(w, {
1930 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
1931 (3, self.remote_network_address, option),
1937 impl Readable for Init {
1938 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1939 let global_features: InitFeatures = Readable::read(r)?;
1940 let features: InitFeatures = Readable::read(r)?;
1941 let mut remote_network_address: Option<SocketAddress> = None;
1942 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
1943 decode_tlv_stream!(r, {
1944 (1, networks, option),
1945 (3, remote_network_address, option)
1948 features: features | global_features,
1949 networks: networks.map(|n| n.0),
1950 remote_network_address,
1955 impl_writeable_msg!(OpenChannel, {
1957 temporary_channel_id,
1960 dust_limit_satoshis,
1961 max_htlc_value_in_flight_msat,
1962 channel_reserve_satoshis,
1968 revocation_basepoint,
1970 delayed_payment_basepoint,
1972 first_per_commitment_point,
1975 (0, shutdown_scriptpubkey, (option, encoding: (Script, WithoutLength))), // Don't encode length twice.
1976 (1, channel_type, option),
1979 impl_writeable_msg!(OpenChannelV2, {
1981 temporary_channel_id,
1982 funding_feerate_sat_per_1000_weight,
1983 commitment_feerate_sat_per_1000_weight,
1985 dust_limit_satoshis,
1986 max_htlc_value_in_flight_msat,
1992 revocation_basepoint,
1994 delayed_payment_basepoint,
1996 first_per_commitment_point,
1997 second_per_commitment_point,
2000 (0, shutdown_scriptpubkey, option),
2001 (1, channel_type, option),
2002 (2, require_confirmed_inputs, option),
2005 #[cfg(not(taproot))]
2006 impl_writeable_msg!(RevokeAndACK, {
2008 per_commitment_secret,
2009 next_per_commitment_point
2013 impl_writeable_msg!(RevokeAndACK, {
2015 per_commitment_secret,
2016 next_per_commitment_point
2018 (4, next_local_nonce, option)
2021 impl_writeable_msg!(Shutdown, {
2026 impl_writeable_msg!(UpdateFailHTLC, {
2032 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2039 impl_writeable_msg!(UpdateFee, {
2044 impl_writeable_msg!(UpdateFulfillHTLC, {
2050 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2051 // serialization format in a way which assumes we know the total serialized length/message end
2053 impl_writeable!(OnionErrorPacket, {
2057 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2058 // serialization format in a way which assumes we know the total serialized length/message end
2060 impl Writeable for OnionPacket {
2061 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2062 self.version.write(w)?;
2063 match self.public_key {
2064 Ok(pubkey) => pubkey.write(w)?,
2065 Err(_) => [0u8;33].write(w)?,
2067 w.write_all(&self.hop_data)?;
2068 self.hmac.write(w)?;
2073 impl Readable for OnionPacket {
2074 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2076 version: Readable::read(r)?,
2078 let mut buf = [0u8;33];
2079 r.read_exact(&mut buf)?;
2080 PublicKey::from_slice(&buf)
2082 hop_data: Readable::read(r)?,
2083 hmac: Readable::read(r)?,
2088 impl_writeable_msg!(UpdateAddHTLC, {
2094 onion_routing_packet,
2096 (65537, skimmed_fee_msat, option)
2099 impl Readable for OnionMessage {
2100 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2101 let blinding_point: PublicKey = Readable::read(r)?;
2102 let len: u16 = Readable::read(r)?;
2103 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2104 let onion_routing_packet: onion_message::Packet = <onion_message::Packet as LengthReadable>::read(&mut packet_reader)?;
2107 onion_routing_packet,
2112 impl Writeable for OnionMessage {
2113 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2114 self.blinding_point.write(w)?;
2115 let onion_packet_len = self.onion_routing_packet.serialized_length();
2116 (onion_packet_len as u16).write(w)?;
2117 self.onion_routing_packet.write(w)?;
2122 impl Writeable for FinalOnionHopData {
2123 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2124 self.payment_secret.0.write(w)?;
2125 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2129 impl Readable for FinalOnionHopData {
2130 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2131 let secret: [u8; 32] = Readable::read(r)?;
2132 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2133 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2137 impl Writeable for OutboundOnionPayload {
2138 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2140 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2141 _encode_varint_length_prefixed_tlv!(w, {
2142 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2143 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2144 (6, short_channel_id, required)
2148 ref payment_data, ref payment_metadata, ref keysend_preimage, amt_msat,
2149 outgoing_cltv_value, ref custom_tlvs,
2151 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2152 // to reject any reserved types in the experimental range if new ones are ever
2154 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2155 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2156 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2157 _encode_varint_length_prefixed_tlv!(w, {
2158 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2159 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2160 (8, payment_data, option),
2161 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2162 }, custom_tlvs.iter());
2164 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2165 _encode_varint_length_prefixed_tlv!(w, {
2166 (10, *encrypted_tlvs, required_vec),
2167 (12, intro_node_blinding_point, option)
2170 Self::BlindedReceive {
2171 amt_msat, total_msat, outgoing_cltv_value, encrypted_tlvs,
2172 intro_node_blinding_point,
2174 _encode_varint_length_prefixed_tlv!(w, {
2175 (2, HighZeroBytesDroppedBigSize(*amt_msat), required),
2176 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2177 (10, *encrypted_tlvs, required_vec),
2178 (12, intro_node_blinding_point, option),
2179 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2187 impl<NS: Deref> ReadableArgs<&NS> for InboundOnionPayload where NS::Target: NodeSigner {
2188 fn read<R: Read>(r: &mut R, node_signer: &NS) -> Result<Self, DecodeError> {
2190 let mut cltv_value = None;
2191 let mut short_id: Option<u64> = None;
2192 let mut payment_data: Option<FinalOnionHopData> = None;
2193 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2194 let mut intro_node_blinding_point = None;
2195 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2196 let mut total_msat = None;
2197 let mut keysend_preimage: Option<PaymentPreimage> = None;
2198 let mut custom_tlvs = Vec::new();
2200 let tlv_len = BigSize::read(r)?;
2201 let rd = FixedLengthReader::new(r, tlv_len.0);
2202 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2203 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2204 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2205 (6, short_id, option),
2206 (8, payment_data, option),
2207 (10, encrypted_tlvs_opt, option),
2208 (12, intro_node_blinding_point, option),
2209 (16, payment_metadata, option),
2210 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2211 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2212 (5482373484, keysend_preimage, option)
2213 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2214 if msg_type < 1 << 16 { return Ok(false) }
2215 let mut value = Vec::new();
2216 msg_reader.read_to_end(&mut value)?;
2217 custom_tlvs.push((msg_type, value));
2221 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2223 if let Some(blinding_point) = intro_node_blinding_point {
2224 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2225 return Err(DecodeError::InvalidValue)
2227 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2228 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2229 .map_err(|_| DecodeError::InvalidValue)?;
2230 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2231 let mut s = Cursor::new(&enc_tlvs);
2232 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2233 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2234 ChaChaPolyReadAdapter { readable: ReceiveTlvs { payment_secret, payment_constraints }} => {
2235 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2236 Ok(Self::BlindedReceive {
2237 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2238 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2239 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2241 payment_constraints,
2242 intro_node_blinding_point: blinding_point,
2246 } else if let Some(short_channel_id) = short_id {
2247 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2248 total_msat.is_some()
2249 { return Err(DecodeError::InvalidValue) }
2252 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2253 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2256 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2257 return Err(DecodeError::InvalidValue)
2259 if let Some(data) = &payment_data {
2260 if data.total_msat > MAX_VALUE_MSAT {
2261 return Err(DecodeError::InvalidValue);
2266 payment_metadata: payment_metadata.map(|w| w.0),
2268 amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2269 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2276 impl Writeable for Ping {
2277 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2278 self.ponglen.write(w)?;
2279 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2284 impl Readable for Ping {
2285 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2287 ponglen: Readable::read(r)?,
2289 let byteslen = Readable::read(r)?;
2290 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2297 impl Writeable for Pong {
2298 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2299 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2304 impl Readable for Pong {
2305 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2308 let byteslen = Readable::read(r)?;
2309 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2316 impl Writeable for UnsignedChannelAnnouncement {
2317 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2318 self.features.write(w)?;
2319 self.chain_hash.write(w)?;
2320 self.short_channel_id.write(w)?;
2321 self.node_id_1.write(w)?;
2322 self.node_id_2.write(w)?;
2323 self.bitcoin_key_1.write(w)?;
2324 self.bitcoin_key_2.write(w)?;
2325 w.write_all(&self.excess_data[..])?;
2330 impl Readable for UnsignedChannelAnnouncement {
2331 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2333 features: Readable::read(r)?,
2334 chain_hash: Readable::read(r)?,
2335 short_channel_id: Readable::read(r)?,
2336 node_id_1: Readable::read(r)?,
2337 node_id_2: Readable::read(r)?,
2338 bitcoin_key_1: Readable::read(r)?,
2339 bitcoin_key_2: Readable::read(r)?,
2340 excess_data: read_to_end(r)?,
2345 impl_writeable!(ChannelAnnouncement, {
2348 bitcoin_signature_1,
2349 bitcoin_signature_2,
2353 impl Writeable for UnsignedChannelUpdate {
2354 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2355 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2356 const MESSAGE_FLAGS: u8 = 1;
2357 self.chain_hash.write(w)?;
2358 self.short_channel_id.write(w)?;
2359 self.timestamp.write(w)?;
2360 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2361 all_flags.write(w)?;
2362 self.cltv_expiry_delta.write(w)?;
2363 self.htlc_minimum_msat.write(w)?;
2364 self.fee_base_msat.write(w)?;
2365 self.fee_proportional_millionths.write(w)?;
2366 self.htlc_maximum_msat.write(w)?;
2367 w.write_all(&self.excess_data[..])?;
2372 impl Readable for UnsignedChannelUpdate {
2373 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2375 chain_hash: Readable::read(r)?,
2376 short_channel_id: Readable::read(r)?,
2377 timestamp: Readable::read(r)?,
2379 let flags: u16 = Readable::read(r)?;
2380 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2383 cltv_expiry_delta: Readable::read(r)?,
2384 htlc_minimum_msat: Readable::read(r)?,
2385 fee_base_msat: Readable::read(r)?,
2386 fee_proportional_millionths: Readable::read(r)?,
2387 htlc_maximum_msat: Readable::read(r)?,
2388 excess_data: read_to_end(r)?,
2393 impl_writeable!(ChannelUpdate, {
2398 impl Writeable for ErrorMessage {
2399 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2400 self.channel_id.write(w)?;
2401 (self.data.len() as u16).write(w)?;
2402 w.write_all(self.data.as_bytes())?;
2407 impl Readable for ErrorMessage {
2408 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2410 channel_id: Readable::read(r)?,
2412 let sz: usize = <u16 as Readable>::read(r)? as usize;
2413 let mut data = Vec::with_capacity(sz);
2415 r.read_exact(&mut data)?;
2416 match String::from_utf8(data) {
2418 Err(_) => return Err(DecodeError::InvalidValue),
2425 impl Writeable for WarningMessage {
2426 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2427 self.channel_id.write(w)?;
2428 (self.data.len() as u16).write(w)?;
2429 w.write_all(self.data.as_bytes())?;
2434 impl Readable for WarningMessage {
2435 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2437 channel_id: Readable::read(r)?,
2439 let sz: usize = <u16 as Readable>::read(r)? as usize;
2440 let mut data = Vec::with_capacity(sz);
2442 r.read_exact(&mut data)?;
2443 match String::from_utf8(data) {
2445 Err(_) => return Err(DecodeError::InvalidValue),
2452 impl Writeable for UnsignedNodeAnnouncement {
2453 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2454 self.features.write(w)?;
2455 self.timestamp.write(w)?;
2456 self.node_id.write(w)?;
2457 w.write_all(&self.rgb)?;
2458 self.alias.write(w)?;
2460 let mut addr_len = 0;
2461 for addr in self.addresses.iter() {
2462 addr_len += 1 + addr.len();
2464 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2465 for addr in self.addresses.iter() {
2468 w.write_all(&self.excess_address_data[..])?;
2469 w.write_all(&self.excess_data[..])?;
2474 impl Readable for UnsignedNodeAnnouncement {
2475 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2476 let features: NodeFeatures = Readable::read(r)?;
2477 let timestamp: u32 = Readable::read(r)?;
2478 let node_id: NodeId = Readable::read(r)?;
2479 let mut rgb = [0; 3];
2480 r.read_exact(&mut rgb)?;
2481 let alias: NodeAlias = Readable::read(r)?;
2483 let addr_len: u16 = Readable::read(r)?;
2484 let mut addresses: Vec<SocketAddress> = Vec::new();
2485 let mut addr_readpos = 0;
2486 let mut excess = false;
2487 let mut excess_byte = 0;
2489 if addr_len <= addr_readpos { break; }
2490 match Readable::read(r) {
2492 if addr_len < addr_readpos + 1 + addr.len() {
2493 return Err(DecodeError::BadLengthDescriptor);
2495 addr_readpos += (1 + addr.len()) as u16;
2496 addresses.push(addr);
2498 Ok(Err(unknown_descriptor)) => {
2500 excess_byte = unknown_descriptor;
2503 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2504 Err(e) => return Err(e),
2508 let mut excess_data = vec![];
2509 let excess_address_data = if addr_readpos < addr_len {
2510 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2511 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2513 excess_address_data[0] = excess_byte;
2518 excess_data.push(excess_byte);
2522 excess_data.extend(read_to_end(r)?.iter());
2523 Ok(UnsignedNodeAnnouncement {
2530 excess_address_data,
2536 impl_writeable!(NodeAnnouncement, {
2541 impl Readable for QueryShortChannelIds {
2542 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2543 let chain_hash: BlockHash = Readable::read(r)?;
2545 let encoding_len: u16 = Readable::read(r)?;
2546 let encoding_type: u8 = Readable::read(r)?;
2548 // Must be encoding_type=0 uncompressed serialization. We do not
2549 // support encoding_type=1 zlib serialization.
2550 if encoding_type != EncodingType::Uncompressed as u8 {
2551 return Err(DecodeError::UnsupportedCompression);
2554 // We expect the encoding_len to always includes the 1-byte
2555 // encoding_type and that short_channel_ids are 8-bytes each
2556 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2557 return Err(DecodeError::InvalidValue);
2560 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2561 // less the 1-byte encoding_type
2562 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2563 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2564 for _ in 0..short_channel_id_count {
2565 short_channel_ids.push(Readable::read(r)?);
2568 Ok(QueryShortChannelIds {
2575 impl Writeable for QueryShortChannelIds {
2576 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2577 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
2578 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2580 self.chain_hash.write(w)?;
2581 encoding_len.write(w)?;
2583 // We only support type=0 uncompressed serialization
2584 (EncodingType::Uncompressed as u8).write(w)?;
2586 for scid in self.short_channel_ids.iter() {
2594 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
2599 impl QueryChannelRange {
2600 /// Calculates the overflow safe ending block height for the query.
2602 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
2603 pub fn end_blocknum(&self) -> u32 {
2604 match self.first_blocknum.checked_add(self.number_of_blocks) {
2605 Some(block) => block,
2606 None => u32::max_value(),
2611 impl_writeable_msg!(QueryChannelRange, {
2617 impl Readable for ReplyChannelRange {
2618 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2619 let chain_hash: BlockHash = Readable::read(r)?;
2620 let first_blocknum: u32 = Readable::read(r)?;
2621 let number_of_blocks: u32 = Readable::read(r)?;
2622 let sync_complete: bool = Readable::read(r)?;
2624 let encoding_len: u16 = Readable::read(r)?;
2625 let encoding_type: u8 = Readable::read(r)?;
2627 // Must be encoding_type=0 uncompressed serialization. We do not
2628 // support encoding_type=1 zlib serialization.
2629 if encoding_type != EncodingType::Uncompressed as u8 {
2630 return Err(DecodeError::UnsupportedCompression);
2633 // We expect the encoding_len to always includes the 1-byte
2634 // encoding_type and that short_channel_ids are 8-bytes each
2635 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
2636 return Err(DecodeError::InvalidValue);
2639 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
2640 // less the 1-byte encoding_type
2641 let short_channel_id_count: u16 = (encoding_len - 1)/8;
2642 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
2643 for _ in 0..short_channel_id_count {
2644 short_channel_ids.push(Readable::read(r)?);
2647 Ok(ReplyChannelRange {
2657 impl Writeable for ReplyChannelRange {
2658 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2659 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
2660 self.chain_hash.write(w)?;
2661 self.first_blocknum.write(w)?;
2662 self.number_of_blocks.write(w)?;
2663 self.sync_complete.write(w)?;
2665 encoding_len.write(w)?;
2666 (EncodingType::Uncompressed as u8).write(w)?;
2667 for scid in self.short_channel_ids.iter() {
2675 impl_writeable_msg!(GossipTimestampFilter, {
2683 use std::convert::TryFrom;
2684 use bitcoin::blockdata::constants::ChainHash;
2685 use bitcoin::{Transaction, PackedLockTime, TxIn, Script, Sequence, Witness, TxOut};
2687 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
2688 use crate::ln::ChannelId;
2689 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
2690 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket};
2691 use crate::ln::msgs::SocketAddress;
2692 use crate::routing::gossip::{NodeAlias, NodeId};
2693 use crate::util::ser::{Writeable, Readable, ReadableArgs, Hostname, TransactionU16LenLimited};
2694 use crate::util::test_utils;
2696 use bitcoin::hashes::hex::FromHex;
2697 use bitcoin::util::address::Address;
2698 use bitcoin::network::constants::Network;
2699 use bitcoin::blockdata::script::Builder;
2700 use bitcoin::blockdata::opcodes;
2701 use bitcoin::hash_types::{Txid, BlockHash};
2703 use bitcoin::secp256k1::{PublicKey,SecretKey};
2704 use bitcoin::secp256k1::{Secp256k1, Message};
2706 use crate::io::{self, Cursor};
2707 use crate::prelude::*;
2708 use core::str::FromStr;
2709 use crate::chain::transaction::OutPoint;
2711 #[cfg(feature = "std")]
2712 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
2713 use crate::ln::msgs::SocketAddressParseError;
2716 fn encoding_channel_reestablish() {
2718 let secp_ctx = Secp256k1::new();
2719 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2722 let cr = msgs::ChannelReestablish {
2723 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]),
2724 next_local_commitment_number: 3,
2725 next_remote_commitment_number: 4,
2726 your_last_per_commitment_secret: [9;32],
2727 my_current_per_commitment_point: public_key,
2728 next_funding_txid: None,
2731 let encoded_value = cr.encode();
2735 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
2736 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2737 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2738 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
2739 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
2745 fn encoding_channel_reestablish_with_next_funding_txid() {
2747 let secp_ctx = Secp256k1::new();
2748 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
2751 let cr = msgs::ChannelReestablish {
2752 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]),
2753 next_local_commitment_number: 3,
2754 next_remote_commitment_number: 4,
2755 your_last_per_commitment_secret: [9;32],
2756 my_current_per_commitment_point: public_key,
2757 next_funding_txid: Some(Txid::from_hash(bitcoin::hashes::Hash::from_slice(&[
2758 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,
2762 let encoded_value = cr.encode();
2766 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
2767 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
2768 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
2769 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
2770 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
2771 0, // Type (next_funding_txid)
2773 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
2778 macro_rules! get_keys_from {
2779 ($slice: expr, $secp_ctx: expr) => {
2781 let privkey = SecretKey::from_slice(&hex::decode($slice).unwrap()[..]).unwrap();
2782 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
2788 macro_rules! get_sig_on {
2789 ($privkey: expr, $ctx: expr, $string: expr) => {
2791 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
2792 $ctx.sign_ecdsa(&sighash, &$privkey)
2798 fn encoding_announcement_signatures() {
2799 let secp_ctx = Secp256k1::new();
2800 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2801 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
2802 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
2803 let announcement_signatures = msgs::AnnouncementSignatures {
2804 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]),
2805 short_channel_id: 2316138423780173,
2806 node_signature: sig_1,
2807 bitcoin_signature: sig_2,
2810 let encoded_value = announcement_signatures.encode();
2811 assert_eq!(encoded_value, hex::decode("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
2814 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
2815 let secp_ctx = Secp256k1::new();
2816 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2817 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
2818 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
2819 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
2820 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2821 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
2822 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
2823 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
2824 let mut features = ChannelFeatures::empty();
2825 if unknown_features_bits {
2826 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
2828 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
2830 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2831 short_channel_id: 2316138423780173,
2832 node_id_1: NodeId::from_pubkey(&pubkey_1),
2833 node_id_2: NodeId::from_pubkey(&pubkey_2),
2834 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
2835 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
2836 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
2838 let channel_announcement = msgs::ChannelAnnouncement {
2839 node_signature_1: sig_1,
2840 node_signature_2: sig_2,
2841 bitcoin_signature_1: sig_3,
2842 bitcoin_signature_2: sig_4,
2843 contents: unsigned_channel_announcement,
2845 let encoded_value = channel_announcement.encode();
2846 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
2847 if unknown_features_bits {
2848 target_value.append(&mut hex::decode("0002ffff").unwrap());
2850 target_value.append(&mut hex::decode("0000").unwrap());
2852 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2853 target_value.append(&mut hex::decode("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
2855 target_value.append(&mut hex::decode("0a00001400001e000028").unwrap());
2857 assert_eq!(encoded_value, target_value);
2861 fn encoding_channel_announcement() {
2862 do_encoding_channel_announcement(true, false);
2863 do_encoding_channel_announcement(false, true);
2864 do_encoding_channel_announcement(false, false);
2865 do_encoding_channel_announcement(true, true);
2868 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) {
2869 let secp_ctx = Secp256k1::new();
2870 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2871 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2872 let features = if unknown_features_bits {
2873 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
2875 // Set to some features we may support
2876 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
2878 let mut addresses = Vec::new();
2880 addresses.push(SocketAddress::TcpIpV4 {
2881 addr: [255, 254, 253, 252],
2886 addresses.push(SocketAddress::TcpIpV6 {
2887 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
2892 addresses.push(msgs::SocketAddress::OnionV2(
2893 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
2897 addresses.push(msgs::SocketAddress::OnionV3 {
2898 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],
2905 addresses.push(SocketAddress::Hostname {
2906 hostname: Hostname::try_from(String::from("host")).unwrap(),
2910 let mut addr_len = 0;
2911 for addr in &addresses {
2912 addr_len += addr.len() + 1;
2914 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
2916 timestamp: 20190119,
2917 node_id: NodeId::from_pubkey(&pubkey_1),
2919 alias: NodeAlias([16;32]),
2921 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() },
2922 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() },
2924 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
2925 let node_announcement = msgs::NodeAnnouncement {
2927 contents: unsigned_node_announcement,
2929 let encoded_value = node_announcement.encode();
2930 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2931 if unknown_features_bits {
2932 target_value.append(&mut hex::decode("0002ffff").unwrap());
2934 target_value.append(&mut hex::decode("000122").unwrap());
2936 target_value.append(&mut hex::decode("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
2937 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
2939 target_value.append(&mut hex::decode("01fffefdfc2607").unwrap());
2942 target_value.append(&mut hex::decode("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
2945 target_value.append(&mut hex::decode("03fffefdfcfbfaf9f8f7f62607").unwrap());
2948 target_value.append(&mut hex::decode("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
2951 target_value.append(&mut hex::decode("0504686f73742607").unwrap());
2953 if excess_address_data {
2954 target_value.append(&mut hex::decode("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
2957 target_value.append(&mut hex::decode("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
2959 assert_eq!(encoded_value, target_value);
2963 fn encoding_node_announcement() {
2964 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
2965 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
2966 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
2967 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
2968 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
2969 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
2970 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
2971 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
2972 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
2973 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
2976 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
2977 let secp_ctx = Secp256k1::new();
2978 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
2979 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
2980 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
2981 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
2982 short_channel_id: 2316138423780173,
2983 timestamp: 20190119,
2984 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
2985 cltv_expiry_delta: 144,
2986 htlc_minimum_msat: 1000000,
2987 htlc_maximum_msat: 131355275467161,
2988 fee_base_msat: 10000,
2989 fee_proportional_millionths: 20,
2990 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
2992 let channel_update = msgs::ChannelUpdate {
2994 contents: unsigned_channel_update
2996 let encoded_value = channel_update.encode();
2997 let mut target_value = hex::decode("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
2998 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
2999 target_value.append(&mut hex::decode("00083a840000034d013413a7").unwrap());
3000 target_value.append(&mut hex::decode("01").unwrap());
3001 target_value.append(&mut hex::decode("00").unwrap());
3003 let flag = target_value.last_mut().unwrap();
3007 let flag = target_value.last_mut().unwrap();
3008 *flag = *flag | 1 << 1;
3010 target_value.append(&mut hex::decode("009000000000000f42400000271000000014").unwrap());
3011 target_value.append(&mut hex::decode("0000777788889999").unwrap());
3013 target_value.append(&mut hex::decode("000000003b9aca00").unwrap());
3015 assert_eq!(encoded_value, target_value);
3019 fn encoding_channel_update() {
3020 do_encoding_channel_update(false, false, false);
3021 do_encoding_channel_update(false, false, true);
3022 do_encoding_channel_update(true, false, false);
3023 do_encoding_channel_update(true, false, true);
3024 do_encoding_channel_update(false, true, false);
3025 do_encoding_channel_update(false, true, true);
3026 do_encoding_channel_update(true, true, false);
3027 do_encoding_channel_update(true, true, true);
3030 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3031 let secp_ctx = Secp256k1::new();
3032 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3033 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3034 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3035 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3036 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3037 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3038 let open_channel = msgs::OpenChannel {
3039 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3040 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3041 funding_satoshis: 1311768467284833366,
3042 push_msat: 2536655962884945560,
3043 dust_limit_satoshis: 3608586615801332854,
3044 max_htlc_value_in_flight_msat: 8517154655701053848,
3045 channel_reserve_satoshis: 8665828695742877976,
3046 htlc_minimum_msat: 2316138423780173,
3047 feerate_per_kw: 821716,
3048 to_self_delay: 49340,
3049 max_accepted_htlcs: 49340,
3050 funding_pubkey: pubkey_1,
3051 revocation_basepoint: pubkey_2,
3052 payment_point: pubkey_3,
3053 delayed_payment_basepoint: pubkey_4,
3054 htlc_basepoint: pubkey_5,
3055 first_per_commitment_point: pubkey_6,
3056 channel_flags: if random_bit { 1 << 5 } else { 0 },
3057 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3058 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3060 let encoded_value = open_channel.encode();
3061 let mut target_value = Vec::new();
3062 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
3063 target_value.append(&mut hex::decode("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3065 target_value.append(&mut hex::decode("20").unwrap());
3067 target_value.append(&mut hex::decode("00").unwrap());
3070 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3073 target_value.append(&mut hex::decode("0100").unwrap());
3075 assert_eq!(encoded_value, target_value);
3079 fn encoding_open_channel() {
3080 do_encoding_open_channel(false, false, false);
3081 do_encoding_open_channel(false, false, true);
3082 do_encoding_open_channel(false, true, false);
3083 do_encoding_open_channel(false, true, true);
3084 do_encoding_open_channel(true, false, false);
3085 do_encoding_open_channel(true, false, true);
3086 do_encoding_open_channel(true, true, false);
3087 do_encoding_open_channel(true, true, true);
3090 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3091 let secp_ctx = Secp256k1::new();
3092 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3093 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3094 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3095 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3096 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3097 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3098 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3099 let open_channelv2 = msgs::OpenChannelV2 {
3100 chain_hash: BlockHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3101 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3102 funding_feerate_sat_per_1000_weight: 821716,
3103 commitment_feerate_sat_per_1000_weight: 821716,
3104 funding_satoshis: 1311768467284833366,
3105 dust_limit_satoshis: 3608586615801332854,
3106 max_htlc_value_in_flight_msat: 8517154655701053848,
3107 htlc_minimum_msat: 2316138423780173,
3108 to_self_delay: 49340,
3109 max_accepted_htlcs: 49340,
3110 locktime: 305419896,
3111 funding_pubkey: pubkey_1,
3112 revocation_basepoint: pubkey_2,
3113 payment_basepoint: pubkey_3,
3114 delayed_payment_basepoint: pubkey_4,
3115 htlc_basepoint: pubkey_5,
3116 first_per_commitment_point: pubkey_6,
3117 second_per_commitment_point: pubkey_7,
3118 channel_flags: if random_bit { 1 << 5 } else { 0 },
3119 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3120 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3121 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3123 let encoded_value = open_channelv2.encode();
3124 let mut target_value = Vec::new();
3125 target_value.append(&mut hex::decode("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f").unwrap());
3126 target_value.append(&mut hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3127 target_value.append(&mut hex::decode("000c89d4").unwrap());
3128 target_value.append(&mut hex::decode("000c89d4").unwrap());
3129 target_value.append(&mut hex::decode("1234567890123456").unwrap());
3130 target_value.append(&mut hex::decode("3214466870114476").unwrap());
3131 target_value.append(&mut hex::decode("7633030896203198").unwrap());
3132 target_value.append(&mut hex::decode("00083a840000034d").unwrap());
3133 target_value.append(&mut hex::decode("c0bc").unwrap());
3134 target_value.append(&mut hex::decode("c0bc").unwrap());
3135 target_value.append(&mut hex::decode("12345678").unwrap());
3136 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3137 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3138 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3139 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3140 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3141 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3142 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3145 target_value.append(&mut hex::decode("20").unwrap());
3147 target_value.append(&mut hex::decode("00").unwrap());
3150 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3151 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3154 target_value.append(&mut hex::decode("0100").unwrap());
3156 if require_confirmed_inputs {
3157 target_value.append(&mut hex::decode("0200").unwrap());
3159 assert_eq!(encoded_value, target_value);
3163 fn encoding_open_channelv2() {
3164 do_encoding_open_channelv2(false, false, false, false);
3165 do_encoding_open_channelv2(false, false, false, true);
3166 do_encoding_open_channelv2(false, false, true, false);
3167 do_encoding_open_channelv2(false, false, true, true);
3168 do_encoding_open_channelv2(false, true, false, false);
3169 do_encoding_open_channelv2(false, true, false, true);
3170 do_encoding_open_channelv2(false, true, true, false);
3171 do_encoding_open_channelv2(false, true, true, true);
3172 do_encoding_open_channelv2(true, false, false, false);
3173 do_encoding_open_channelv2(true, false, false, true);
3174 do_encoding_open_channelv2(true, false, true, false);
3175 do_encoding_open_channelv2(true, false, true, true);
3176 do_encoding_open_channelv2(true, true, false, false);
3177 do_encoding_open_channelv2(true, true, false, true);
3178 do_encoding_open_channelv2(true, true, true, false);
3179 do_encoding_open_channelv2(true, true, true, true);
3182 fn do_encoding_accept_channel(shutdown: bool) {
3183 let secp_ctx = Secp256k1::new();
3184 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3185 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3186 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3187 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3188 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3189 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3190 let accept_channel = msgs::AcceptChannel {
3191 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3192 dust_limit_satoshis: 1311768467284833366,
3193 max_htlc_value_in_flight_msat: 2536655962884945560,
3194 channel_reserve_satoshis: 3608586615801332854,
3195 htlc_minimum_msat: 2316138423780173,
3196 minimum_depth: 821716,
3197 to_self_delay: 49340,
3198 max_accepted_htlcs: 49340,
3199 funding_pubkey: pubkey_1,
3200 revocation_basepoint: pubkey_2,
3201 payment_point: pubkey_3,
3202 delayed_payment_basepoint: pubkey_4,
3203 htlc_basepoint: pubkey_5,
3204 first_per_commitment_point: pubkey_6,
3205 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3208 next_local_nonce: None,
3210 let encoded_value = accept_channel.encode();
3211 let mut target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3213 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3215 assert_eq!(encoded_value, target_value);
3219 fn encoding_accept_channel() {
3220 do_encoding_accept_channel(false);
3221 do_encoding_accept_channel(true);
3224 fn do_encoding_accept_channelv2(shutdown: bool) {
3225 let secp_ctx = Secp256k1::new();
3226 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3227 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3228 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3229 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3230 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3231 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3232 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3233 let accept_channelv2 = msgs::AcceptChannelV2 {
3234 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3235 funding_satoshis: 1311768467284833366,
3236 dust_limit_satoshis: 1311768467284833366,
3237 max_htlc_value_in_flight_msat: 2536655962884945560,
3238 htlc_minimum_msat: 2316138423780173,
3239 minimum_depth: 821716,
3240 to_self_delay: 49340,
3241 max_accepted_htlcs: 49340,
3242 funding_pubkey: pubkey_1,
3243 revocation_basepoint: pubkey_2,
3244 payment_basepoint: pubkey_3,
3245 delayed_payment_basepoint: pubkey_4,
3246 htlc_basepoint: pubkey_5,
3247 first_per_commitment_point: pubkey_6,
3248 second_per_commitment_point: pubkey_7,
3249 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3251 require_confirmed_inputs: None,
3253 let encoded_value = accept_channelv2.encode();
3254 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3255 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // funding_satoshis
3256 target_value.append(&mut hex::decode("1234567890123456").unwrap()); // dust_limit_satoshis
3257 target_value.append(&mut hex::decode("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3258 target_value.append(&mut hex::decode("00083a840000034d").unwrap()); // htlc_minimum_msat
3259 target_value.append(&mut hex::decode("000c89d4").unwrap()); // minimum_depth
3260 target_value.append(&mut hex::decode("c0bc").unwrap()); // to_self_delay
3261 target_value.append(&mut hex::decode("c0bc").unwrap()); // max_accepted_htlcs
3262 target_value.append(&mut hex::decode("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3263 target_value.append(&mut hex::decode("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3264 target_value.append(&mut hex::decode("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3265 target_value.append(&mut hex::decode("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3266 target_value.append(&mut hex::decode("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3267 target_value.append(&mut hex::decode("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3268 target_value.append(&mut hex::decode("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3270 target_value.append(&mut hex::decode("001b").unwrap()); // Type 0 + Length 27
3271 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3273 assert_eq!(encoded_value, target_value);
3277 fn encoding_accept_channelv2() {
3278 do_encoding_accept_channelv2(false);
3279 do_encoding_accept_channelv2(true);
3283 fn encoding_funding_created() {
3284 let secp_ctx = Secp256k1::new();
3285 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3286 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3287 let funding_created = msgs::FundingCreated {
3288 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3289 funding_txid: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3290 funding_output_index: 255,
3293 partial_signature_with_nonce: None,
3295 next_local_nonce: None,
3297 let encoded_value = funding_created.encode();
3298 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3299 assert_eq!(encoded_value, target_value);
3303 fn encoding_funding_signed() {
3304 let secp_ctx = Secp256k1::new();
3305 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3306 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3307 let funding_signed = msgs::FundingSigned {
3308 channel_id: ChannelId::from_bytes([2; 32]),
3311 partial_signature_with_nonce: None,
3313 let encoded_value = funding_signed.encode();
3314 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3315 assert_eq!(encoded_value, target_value);
3319 fn encoding_channel_ready() {
3320 let secp_ctx = Secp256k1::new();
3321 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3322 let channel_ready = msgs::ChannelReady {
3323 channel_id: ChannelId::from_bytes([2; 32]),
3324 next_per_commitment_point: pubkey_1,
3325 short_channel_id_alias: None,
3327 let encoded_value = channel_ready.encode();
3328 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3329 assert_eq!(encoded_value, target_value);
3333 fn encoding_tx_add_input() {
3334 let tx_add_input = msgs::TxAddInput {
3335 channel_id: ChannelId::from_bytes([2; 32]),
3336 serial_id: 4886718345,
3337 prevtx: TransactionU16LenLimited::new(Transaction {
3339 lock_time: PackedLockTime(0),
3341 previous_output: OutPoint { txid: Txid::from_hex("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3342 script_sig: Script::new(),
3343 sequence: Sequence(0xfffffffd),
3344 witness: Witness::from_vec(vec![
3345 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3346 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3351 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().script_pubkey(),
3355 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3359 prevtx_out: 305419896,
3360 sequence: 305419896,
3362 let encoded_value = tx_add_input.encode();
3363 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3364 assert_eq!(encoded_value, target_value);
3368 fn encoding_tx_add_output() {
3369 let tx_add_output = msgs::TxAddOutput {
3370 channel_id: ChannelId::from_bytes([2; 32]),
3371 serial_id: 4886718345,
3373 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().script_pubkey(),
3375 let encoded_value = tx_add_output.encode();
3376 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3377 assert_eq!(encoded_value, target_value);
3381 fn encoding_tx_remove_input() {
3382 let tx_remove_input = msgs::TxRemoveInput {
3383 channel_id: ChannelId::from_bytes([2; 32]),
3384 serial_id: 4886718345,
3386 let encoded_value = tx_remove_input.encode();
3387 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3388 assert_eq!(encoded_value, target_value);
3392 fn encoding_tx_remove_output() {
3393 let tx_remove_output = msgs::TxRemoveOutput {
3394 channel_id: ChannelId::from_bytes([2; 32]),
3395 serial_id: 4886718345,
3397 let encoded_value = tx_remove_output.encode();
3398 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3399 assert_eq!(encoded_value, target_value);
3403 fn encoding_tx_complete() {
3404 let tx_complete = msgs::TxComplete {
3405 channel_id: ChannelId::from_bytes([2; 32]),
3407 let encoded_value = tx_complete.encode();
3408 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3409 assert_eq!(encoded_value, target_value);
3413 fn encoding_tx_signatures() {
3414 let tx_signatures = msgs::TxSignatures {
3415 channel_id: ChannelId::from_bytes([2; 32]),
3416 tx_hash: Txid::from_hex("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3418 Witness::from_vec(vec![
3419 hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3420 hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3421 Witness::from_vec(vec![
3422 hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3423 hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3426 let encoded_value = tx_signatures.encode();
3427 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3428 target_value.append(&mut hex::decode("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3429 target_value.append(&mut hex::decode("0002").unwrap()); // num_witnesses (u16)
3431 target_value.append(&mut hex::decode("006b").unwrap()); // len of witness_data
3432 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3433 target_value.append(&mut hex::decode("47").unwrap()); // len of witness element data (VarInt)
3434 target_value.append(&mut hex::decode("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3435 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3436 target_value.append(&mut hex::decode("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3438 target_value.append(&mut hex::decode("006c").unwrap()); // len of witness_data
3439 target_value.append(&mut hex::decode("02").unwrap()); // num_witness_elements (VarInt)
3440 target_value.append(&mut hex::decode("48").unwrap()); // len of witness element data (VarInt)
3441 target_value.append(&mut hex::decode("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3442 target_value.append(&mut hex::decode("21").unwrap()); // len of witness element data (VarInt)
3443 target_value.append(&mut hex::decode("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3444 assert_eq!(encoded_value, target_value);
3447 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3448 let tx_init_rbf = msgs::TxInitRbf {
3449 channel_id: ChannelId::from_bytes([2; 32]),
3450 locktime: 305419896,
3451 feerate_sat_per_1000_weight: 20190119,
3452 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3454 let encoded_value = tx_init_rbf.encode();
3455 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3456 target_value.append(&mut hex::decode("12345678").unwrap()); // locktime
3457 target_value.append(&mut hex::decode("013413a7").unwrap()); // feerate_sat_per_1000_weight
3458 if let Some((_, target)) = funding_value_with_hex_target {
3459 target_value.push(0x00); // Type
3460 target_value.push(target.len() as u8 / 2); // Length
3461 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3463 assert_eq!(encoded_value, target_value);
3467 fn encoding_tx_init_rbf() {
3468 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3469 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3470 do_encoding_tx_init_rbf(None);
3473 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3474 let tx_ack_rbf = msgs::TxAckRbf {
3475 channel_id: ChannelId::from_bytes([2; 32]),
3476 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3478 let encoded_value = tx_ack_rbf.encode();
3479 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3480 if let Some((_, target)) = funding_value_with_hex_target {
3481 target_value.push(0x00); // Type
3482 target_value.push(target.len() as u8 / 2); // Length
3483 target_value.append(&mut hex::decode(target).unwrap()); // Value (i64)
3485 assert_eq!(encoded_value, target_value);
3489 fn encoding_tx_ack_rbf() {
3490 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3491 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3492 do_encoding_tx_ack_rbf(None);
3496 fn encoding_tx_abort() {
3497 let tx_abort = msgs::TxAbort {
3498 channel_id: ChannelId::from_bytes([2; 32]),
3499 data: hex::decode("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
3501 let encoded_value = tx_abort.encode();
3502 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
3503 assert_eq!(encoded_value, target_value);
3506 fn do_encoding_shutdown(script_type: u8) {
3507 let secp_ctx = Secp256k1::new();
3508 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3509 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
3510 let shutdown = msgs::Shutdown {
3511 channel_id: ChannelId::from_bytes([2; 32]),
3513 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
3514 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
3515 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
3516 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
3518 let encoded_value = shutdown.encode();
3519 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3520 if script_type == 1 {
3521 target_value.append(&mut hex::decode("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3522 } else if script_type == 2 {
3523 target_value.append(&mut hex::decode("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
3524 } else if script_type == 3 {
3525 target_value.append(&mut hex::decode("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
3526 } else if script_type == 4 {
3527 target_value.append(&mut hex::decode("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
3529 assert_eq!(encoded_value, target_value);
3533 fn encoding_shutdown() {
3534 do_encoding_shutdown(1);
3535 do_encoding_shutdown(2);
3536 do_encoding_shutdown(3);
3537 do_encoding_shutdown(4);
3541 fn encoding_closing_signed() {
3542 let secp_ctx = Secp256k1::new();
3543 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3544 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3545 let closing_signed = msgs::ClosingSigned {
3546 channel_id: ChannelId::from_bytes([2; 32]),
3547 fee_satoshis: 2316138423780173,
3551 let encoded_value = closing_signed.encode();
3552 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3553 assert_eq!(encoded_value, target_value);
3554 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
3556 let closing_signed_with_range = msgs::ClosingSigned {
3557 channel_id: ChannelId::from_bytes([2; 32]),
3558 fee_satoshis: 2316138423780173,
3560 fee_range: Some(msgs::ClosingSignedFeeRange {
3561 min_fee_satoshis: 0xdeadbeef,
3562 max_fee_satoshis: 0x1badcafe01234567,
3565 let encoded_value_with_range = closing_signed_with_range.encode();
3566 let target_value_with_range = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
3567 assert_eq!(encoded_value_with_range, target_value_with_range);
3568 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
3569 closing_signed_with_range);
3573 fn encoding_update_add_htlc() {
3574 let secp_ctx = Secp256k1::new();
3575 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3576 let onion_routing_packet = msgs::OnionPacket {
3578 public_key: Ok(pubkey_1),
3579 hop_data: [1; 20*65],
3582 let update_add_htlc = msgs::UpdateAddHTLC {
3583 channel_id: ChannelId::from_bytes([2; 32]),
3584 htlc_id: 2316138423780173,
3585 amount_msat: 3608586615801332854,
3586 payment_hash: PaymentHash([1; 32]),
3587 cltv_expiry: 821716,
3588 onion_routing_packet,
3589 skimmed_fee_msat: None,
3591 let encoded_value = update_add_htlc.encode();
3592 let target_value = hex::decode("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").unwrap();
3593 assert_eq!(encoded_value, target_value);
3597 fn encoding_update_fulfill_htlc() {
3598 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
3599 channel_id: ChannelId::from_bytes([2; 32]),
3600 htlc_id: 2316138423780173,
3601 payment_preimage: PaymentPreimage([1; 32]),
3603 let encoded_value = update_fulfill_htlc.encode();
3604 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
3605 assert_eq!(encoded_value, target_value);
3609 fn encoding_update_fail_htlc() {
3610 let reason = OnionErrorPacket {
3611 data: [1; 32].to_vec(),
3613 let update_fail_htlc = msgs::UpdateFailHTLC {
3614 channel_id: ChannelId::from_bytes([2; 32]),
3615 htlc_id: 2316138423780173,
3618 let encoded_value = update_fail_htlc.encode();
3619 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
3620 assert_eq!(encoded_value, target_value);
3624 fn encoding_update_fail_malformed_htlc() {
3625 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
3626 channel_id: ChannelId::from_bytes([2; 32]),
3627 htlc_id: 2316138423780173,
3628 sha256_of_onion: [1; 32],
3631 let encoded_value = update_fail_malformed_htlc.encode();
3632 let target_value = hex::decode("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
3633 assert_eq!(encoded_value, target_value);
3636 fn do_encoding_commitment_signed(htlcs: bool) {
3637 let secp_ctx = Secp256k1::new();
3638 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3639 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3640 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3641 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3642 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3643 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3644 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3645 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3646 let commitment_signed = msgs::CommitmentSigned {
3647 channel_id: ChannelId::from_bytes([2; 32]),
3649 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
3651 partial_signature_with_nonce: None,
3653 let encoded_value = commitment_signed.encode();
3654 let mut target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3656 target_value.append(&mut hex::decode("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3658 target_value.append(&mut hex::decode("0000").unwrap());
3660 assert_eq!(encoded_value, target_value);
3664 fn encoding_commitment_signed() {
3665 do_encoding_commitment_signed(true);
3666 do_encoding_commitment_signed(false);
3670 fn encoding_revoke_and_ack() {
3671 let secp_ctx = Secp256k1::new();
3672 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3673 let raa = msgs::RevokeAndACK {
3674 channel_id: ChannelId::from_bytes([2; 32]),
3675 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],
3676 next_per_commitment_point: pubkey_1,
3678 next_local_nonce: None,
3680 let encoded_value = raa.encode();
3681 let target_value = hex::decode("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3682 assert_eq!(encoded_value, target_value);
3686 fn encoding_update_fee() {
3687 let update_fee = msgs::UpdateFee {
3688 channel_id: ChannelId::from_bytes([2; 32]),
3689 feerate_per_kw: 20190119,
3691 let encoded_value = update_fee.encode();
3692 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
3693 assert_eq!(encoded_value, target_value);
3697 fn encoding_init() {
3698 let mainnet_hash = ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap();
3699 assert_eq!(msgs::Init {
3700 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
3701 networks: Some(vec![mainnet_hash]),
3702 remote_network_address: None,
3703 }.encode(), hex::decode("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3704 assert_eq!(msgs::Init {
3705 features: InitFeatures::from_le_bytes(vec![0xFF]),
3707 remote_network_address: None,
3708 }.encode(), hex::decode("0001ff0001ff").unwrap());
3709 assert_eq!(msgs::Init {
3710 features: InitFeatures::from_le_bytes(vec![]),
3711 networks: Some(vec![mainnet_hash]),
3712 remote_network_address: None,
3713 }.encode(), hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3714 assert_eq!(msgs::Init {
3715 features: InitFeatures::from_le_bytes(vec![]),
3716 networks: Some(vec![ChainHash::from(&[1; 32][..]), ChainHash::from(&[2; 32][..])]),
3717 remote_network_address: None,
3718 }.encode(), hex::decode("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
3719 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
3720 networks: Some(vec![mainnet_hash]),
3721 remote_network_address: Some(SocketAddress::TcpIpV4 {
3722 addr: [127, 0, 0, 1],
3726 let encoded_value = init_msg.encode();
3727 let target_value = hex::decode("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
3728 assert_eq!(encoded_value, target_value);
3729 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
3733 fn encoding_error() {
3734 let error = msgs::ErrorMessage {
3735 channel_id: ChannelId::from_bytes([2; 32]),
3736 data: String::from("rust-lightning"),
3738 let encoded_value = error.encode();
3739 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3740 assert_eq!(encoded_value, target_value);
3744 fn encoding_warning() {
3745 let error = msgs::WarningMessage {
3746 channel_id: ChannelId::from_bytes([2; 32]),
3747 data: String::from("rust-lightning"),
3749 let encoded_value = error.encode();
3750 let target_value = hex::decode("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
3751 assert_eq!(encoded_value, target_value);
3755 fn encoding_ping() {
3756 let ping = msgs::Ping {
3760 let encoded_value = ping.encode();
3761 let target_value = hex::decode("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3762 assert_eq!(encoded_value, target_value);
3766 fn encoding_pong() {
3767 let pong = msgs::Pong {
3770 let encoded_value = pong.encode();
3771 let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
3772 assert_eq!(encoded_value, target_value);
3776 fn encoding_nonfinal_onion_hop_data() {
3777 let outbound_msg = msgs::OutboundOnionPayload::Forward {
3778 short_channel_id: 0xdeadbeef1bad1dea,
3779 amt_to_forward: 0x0badf00d01020304,
3780 outgoing_cltv_value: 0xffffffff,
3782 let encoded_value = outbound_msg.encode();
3783 let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
3784 assert_eq!(encoded_value, target_value);
3786 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3787 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3788 if let msgs::InboundOnionPayload::Forward {
3789 short_channel_id, amt_to_forward, outgoing_cltv_value
3791 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
3792 assert_eq!(amt_to_forward, 0x0badf00d01020304);
3793 assert_eq!(outgoing_cltv_value, 0xffffffff);
3794 } else { panic!(); }
3798 fn encoding_final_onion_hop_data() {
3799 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3801 payment_metadata: None,
3802 keysend_preimage: None,
3803 amt_msat: 0x0badf00d01020304,
3804 outgoing_cltv_value: 0xffffffff,
3805 custom_tlvs: vec![],
3807 let encoded_value = outbound_msg.encode();
3808 let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
3809 assert_eq!(encoded_value, target_value);
3811 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3812 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3813 if let msgs::InboundOnionPayload::Receive {
3814 payment_data: None, amt_msat, outgoing_cltv_value, ..
3816 assert_eq!(amt_msat, 0x0badf00d01020304);
3817 assert_eq!(outgoing_cltv_value, 0xffffffff);
3818 } else { panic!(); }
3822 fn encoding_final_onion_hop_data_with_secret() {
3823 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
3824 let outbound_msg = msgs::OutboundOnionPayload::Receive {
3825 payment_data: Some(FinalOnionHopData {
3826 payment_secret: expected_payment_secret,
3827 total_msat: 0x1badca1f
3829 payment_metadata: None,
3830 keysend_preimage: None,
3831 amt_msat: 0x0badf00d01020304,
3832 outgoing_cltv_value: 0xffffffff,
3833 custom_tlvs: vec![],
3835 let encoded_value = outbound_msg.encode();
3836 let target_value = hex::decode("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
3837 assert_eq!(encoded_value, target_value);
3839 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3840 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3841 if let msgs::InboundOnionPayload::Receive {
3842 payment_data: Some(FinalOnionHopData {
3844 total_msat: 0x1badca1f
3846 amt_msat, outgoing_cltv_value,
3847 payment_metadata: None,
3848 keysend_preimage: None,
3851 assert_eq!(payment_secret, expected_payment_secret);
3852 assert_eq!(amt_msat, 0x0badf00d01020304);
3853 assert_eq!(outgoing_cltv_value, 0xffffffff);
3854 assert_eq!(custom_tlvs, vec![]);
3855 } else { panic!(); }
3859 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
3860 // If custom TLVs have type number within the range reserved for protocol, treat them as if
3862 let bad_type_range_tlvs = vec![
3863 ((1 << 16) - 4, vec![42]),
3864 ((1 << 16) - 2, vec![42; 32]),
3866 let mut msg = msgs::OutboundOnionPayload::Receive {
3868 payment_metadata: None,
3869 keysend_preimage: None,
3870 custom_tlvs: bad_type_range_tlvs,
3871 amt_msat: 0x0badf00d01020304,
3872 outgoing_cltv_value: 0xffffffff,
3874 let encoded_value = msg.encode();
3875 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3876 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).is_err());
3877 let good_type_range_tlvs = vec![
3878 ((1 << 16) - 3, vec![42]),
3879 ((1 << 16) - 1, vec![42; 32]),
3881 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
3882 *custom_tlvs = good_type_range_tlvs.clone();
3884 let encoded_value = msg.encode();
3885 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), &&node_signer).unwrap();
3887 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
3893 fn encoding_final_onion_hop_data_with_custom_tlvs() {
3894 let expected_custom_tlvs = vec![
3895 (5482373483, vec![0x12, 0x34]),
3896 (5482373487, vec![0x42u8; 8]),
3898 let msg = msgs::OutboundOnionPayload::Receive {
3900 payment_metadata: None,
3901 keysend_preimage: None,
3902 custom_tlvs: expected_custom_tlvs.clone(),
3903 amt_msat: 0x0badf00d01020304,
3904 outgoing_cltv_value: 0xffffffff,
3906 let encoded_value = msg.encode();
3907 let target_value = hex::decode("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
3908 assert_eq!(encoded_value, target_value);
3909 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
3910 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), &&node_signer).unwrap();
3911 if let msgs::InboundOnionPayload::Receive {
3913 payment_metadata: None,
3914 keysend_preimage: None,
3917 outgoing_cltv_value,
3920 assert_eq!(custom_tlvs, expected_custom_tlvs);
3921 assert_eq!(amt_msat, 0x0badf00d01020304);
3922 assert_eq!(outgoing_cltv_value, 0xffffffff);
3923 } else { panic!(); }
3927 fn query_channel_range_end_blocknum() {
3928 let tests: Vec<(u32, u32, u32)> = vec![
3929 (10000, 1500, 11500),
3930 (0, 0xffffffff, 0xffffffff),
3931 (1, 0xffffffff, 0xffffffff),
3934 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
3935 let sut = msgs::QueryChannelRange {
3936 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3940 assert_eq!(sut.end_blocknum(), expected);
3945 fn encoding_query_channel_range() {
3946 let mut query_channel_range = msgs::QueryChannelRange {
3947 chain_hash: BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap(),
3948 first_blocknum: 100000,
3949 number_of_blocks: 1500,
3951 let encoded_value = query_channel_range.encode();
3952 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000186a0000005dc").unwrap();
3953 assert_eq!(encoded_value, target_value);
3955 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3956 assert_eq!(query_channel_range.first_blocknum, 100000);
3957 assert_eq!(query_channel_range.number_of_blocks, 1500);
3961 fn encoding_reply_channel_range() {
3962 do_encoding_reply_channel_range(0);
3963 do_encoding_reply_channel_range(1);
3966 fn do_encoding_reply_channel_range(encoding_type: u8) {
3967 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206000b8a06000005dc01").unwrap();
3968 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
3969 let mut reply_channel_range = msgs::ReplyChannelRange {
3970 chain_hash: expected_chain_hash,
3971 first_blocknum: 756230,
3972 number_of_blocks: 1500,
3973 sync_complete: true,
3974 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
3977 if encoding_type == 0 {
3978 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
3979 let encoded_value = reply_channel_range.encode();
3980 assert_eq!(encoded_value, target_value);
3982 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
3983 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
3984 assert_eq!(reply_channel_range.first_blocknum, 756230);
3985 assert_eq!(reply_channel_range.number_of_blocks, 1500);
3986 assert_eq!(reply_channel_range.sync_complete, true);
3987 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
3988 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
3989 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
3991 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
3992 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
3993 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
3998 fn encoding_query_short_channel_ids() {
3999 do_encoding_query_short_channel_ids(0);
4000 do_encoding_query_short_channel_ids(1);
4003 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4004 let mut target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206").unwrap();
4005 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4006 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4007 chain_hash: expected_chain_hash,
4008 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4011 if encoding_type == 0 {
4012 target_value.append(&mut hex::decode("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4013 let encoded_value = query_short_channel_ids.encode();
4014 assert_eq!(encoded_value, target_value);
4016 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4017 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4018 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4019 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4020 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4022 target_value.append(&mut hex::decode("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4023 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4024 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4029 fn encoding_reply_short_channel_ids_end() {
4030 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4031 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4032 chain_hash: expected_chain_hash,
4033 full_information: true,
4035 let encoded_value = reply_short_channel_ids_end.encode();
4036 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e220601").unwrap();
4037 assert_eq!(encoded_value, target_value);
4039 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4040 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4041 assert_eq!(reply_short_channel_ids_end.full_information, true);
4045 fn encoding_gossip_timestamp_filter(){
4046 let expected_chain_hash = BlockHash::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4047 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4048 chain_hash: expected_chain_hash,
4049 first_timestamp: 1590000000,
4050 timestamp_range: 0xffff_ffff,
4052 let encoded_value = gossip_timestamp_filter.encode();
4053 let target_value = hex::decode("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e22065ec57980ffffffff").unwrap();
4054 assert_eq!(encoded_value, target_value);
4056 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4057 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4058 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4059 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4063 fn decode_onion_hop_data_len_as_bigsize() {
4064 // Tests that we can decode an onion payload that is >253 bytes.
4065 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4066 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4069 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4070 // payload length to be encoded over multiple bytes rather than a single u8.
4071 let big_payload = encode_big_payload().unwrap();
4072 let mut rd = Cursor::new(&big_payload[..]);
4074 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4075 <msgs::InboundOnionPayload as ReadableArgs<&&test_utils::TestKeysInterface>>
4076 ::read(&mut rd, &&node_signer).unwrap();
4078 // see above test, needs to be a separate method for use of the serialization macros.
4079 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4080 use crate::util::ser::HighZeroBytesDroppedBigSize;
4081 let payload = msgs::OutboundOnionPayload::Forward {
4082 short_channel_id: 0xdeadbeef1bad1dea,
4083 amt_to_forward: 1000,
4084 outgoing_cltv_value: 0xffffffff,
4086 let mut encoded_payload = Vec::new();
4087 let test_bytes = vec![42u8; 1000];
4088 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4089 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4090 (1, test_bytes, required_vec),
4091 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4092 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4093 (6, short_channel_id, required)
4100 #[cfg(feature = "std")]
4101 fn test_socket_address_from_str() {
4102 assert_eq!(SocketAddress::TcpIpV4 {
4103 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4105 }, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4107 assert_eq!(SocketAddress::TcpIpV6 {
4108 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4110 }, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4112 SocketAddress::Hostname {
4113 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4115 }, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4117 SocketAddress::Hostname {
4118 hostname: Hostname::try_from("example.com".to_string()).unwrap(),
4120 }, SocketAddress::from_str("example.com:1234").unwrap());
4121 assert_eq!(SocketAddress::OnionV3 {
4122 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4123 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4127 }, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4128 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4129 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4130 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4131 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4132 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4133 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4134 assert!("localhost".parse::<SocketAddress>().is_err());
4135 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4136 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4137 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4138 assert!("invalid-address".parse::<SocketAddress>().is_err());
4139 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4143 #[cfg(feature = "std")]
4144 fn test_socket_address_to_socket_addrs() {
4145 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4146 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4147 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4148 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4149 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4150 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4151 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4152 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4153 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4157 port: 1234 }.to_socket_addrs().is_err());