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::ScriptBuf;
32 use bitcoin::hash_types::Txid;
34 use crate::blinded_path::payment::{BlindedPaymentTlvs, ForwardTlvs, ReceiveTlvs};
35 use crate::ln::types::{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 #[allow(unused_imports)]
42 use crate::prelude::*;
47 #[cfg(feature = "std")]
48 use core::str::FromStr;
49 #[cfg(feature = "std")]
50 use std::net::SocketAddr;
51 use core::fmt::Display;
52 use crate::io::{self, Cursor, Read};
53 use crate::io_extras::read_to_end;
55 use crate::events::MessageSendEventsProvider;
56 use crate::crypto::streams::ChaChaPolyReadAdapter;
57 use crate::util::logger;
58 use crate::util::ser::{BigSize, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, LengthRead, LengthReadable, LengthReadableArgs, Readable, ReadableArgs, TransactionU16LenLimited, WithoutLength, Writeable, Writer};
59 use crate::util::base32;
61 use crate::routing::gossip::{NodeAlias, NodeId};
63 /// 21 million * 10^8 * 1000
64 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
67 /// A partial signature that also contains the Musig2 nonce its signer used
68 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
69 pub struct PartialSignatureWithNonce(pub musig2::types::PartialSignature, pub musig2::types::PublicNonce);
71 /// An error in decoding a message or struct.
72 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
73 pub enum DecodeError {
74 /// A version byte specified something we don't know how to handle.
76 /// Includes unknown realm byte in an onion hop data packet.
78 /// Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
79 UnknownRequiredFeature,
80 /// Value was invalid.
82 /// For example, a byte which was supposed to be a bool was something other than a 0
83 /// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
84 /// syntactically incorrect, etc.
86 /// The buffer to be read was too short.
88 /// A length descriptor in the packet didn't describe the later data correctly.
90 /// Error from [`std::io`].
92 /// The message included zlib-compressed values, which we don't support.
93 UnsupportedCompression,
94 /// Value is validly encoded but is dangerous to use.
96 /// This is used for things like [`ChannelManager`] deserialization where we want to ensure
97 /// that we don't use a [`ChannelManager`] which is in out of sync with the [`ChannelMonitor`].
98 /// This indicates that there is a critical implementation flaw in the storage implementation
99 /// and it's unsafe to continue.
101 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
102 /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
106 /// An [`init`] message to be sent to or received from a peer.
108 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
109 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
111 /// The relevant features which the sender supports.
112 pub features: InitFeatures,
113 /// Indicates chains the sender is interested in.
115 /// If there are no common chains, the connection will be closed.
116 pub networks: Option<Vec<ChainHash>>,
117 /// The receipient's network address.
119 /// This adds the option to report a remote IP address back to a connecting peer using the init
120 /// message. A node can decide to use that information to discover a potential update to its
121 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
123 pub remote_network_address: Option<SocketAddress>,
126 /// An [`error`] message to be sent to or received from a peer.
128 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
129 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
130 pub struct ErrorMessage {
131 /// The channel ID involved in the error.
133 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
134 /// with the sending peer should be closed.
135 pub channel_id: ChannelId,
136 /// A possibly human-readable error description.
138 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
139 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
140 /// the terminal emulator or the logging subsystem.
144 /// A [`warning`] message to be sent to or received from a peer.
146 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
147 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
148 pub struct WarningMessage {
149 /// The channel ID involved in the warning.
151 /// All-0s indicates a warning unrelated to a specific channel.
152 pub channel_id: ChannelId,
153 /// A possibly human-readable warning description.
155 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
156 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
157 /// the terminal emulator or the logging subsystem.
161 /// A [`ping`] message to be sent to or received from a peer.
163 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
164 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
166 /// The desired response length.
168 /// The ping packet size.
170 /// This field is not sent on the wire. byteslen zeros are sent.
174 /// A [`pong`] message to be sent to or received from a peer.
176 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
177 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
179 /// The pong packet size.
181 /// This field is not sent on the wire. byteslen zeros are sent.
185 /// Contains fields that are both common to [`open_channel`] and `open_channel2` messages.
187 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
188 // TODO(dual_funding): Add spec link for `open_channel2`.
189 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
190 pub struct CommonOpenChannelFields {
191 /// The genesis hash of the blockchain where the channel is to be opened
192 pub chain_hash: ChainHash,
193 /// A temporary channel ID
194 /// For V2 channels: derived using a zeroed out value for the channel acceptor's revocation basepoint
195 /// For V1 channels: a temporary channel ID, until the funding outpoint is announced
196 pub temporary_channel_id: ChannelId,
197 /// For V1 channels: The channel value
198 /// For V2 channels: Part of the channel value contributed by the channel initiator
199 pub funding_satoshis: u64,
200 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
202 pub dust_limit_satoshis: u64,
203 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
204 pub max_htlc_value_in_flight_msat: u64,
205 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
206 pub htlc_minimum_msat: u64,
207 /// The feerate for the commitment transaction set by the channel initiator until updated by
209 pub commitment_feerate_sat_per_1000_weight: u32,
210 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
211 /// broadcast a commitment transaction
212 pub to_self_delay: u16,
213 /// The maximum number of inbound HTLCs towards channel initiator
214 pub max_accepted_htlcs: u16,
215 /// The channel initiator's key controlling the funding transaction
216 pub funding_pubkey: PublicKey,
217 /// Used to derive a revocation key for transactions broadcast by counterparty
218 pub revocation_basepoint: PublicKey,
219 /// A payment key to channel initiator for transactions broadcast by counterparty
220 pub payment_basepoint: PublicKey,
221 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
223 pub delayed_payment_basepoint: PublicKey,
224 /// Used to derive an HTLC payment key to channel initiator
225 pub htlc_basepoint: PublicKey,
226 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
227 pub first_per_commitment_point: PublicKey,
228 /// The channel flags to be used
229 pub channel_flags: u8,
230 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
231 /// collaboratively close
232 pub shutdown_scriptpubkey: Option<ScriptBuf>,
233 /// The channel type that this channel will represent
235 /// If this is `None`, we derive the channel type from the intersection of our
236 /// feature bits with our counterparty's feature bits from the [`Init`] message.
237 pub channel_type: Option<ChannelTypeFeatures>,
240 /// An [`open_channel`] message to be sent to or received from a peer.
242 /// Used in V1 channel establishment
244 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
245 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
246 pub struct OpenChannel {
247 /// Common fields of `open_channel(2)`-like messages
248 pub common_fields: CommonOpenChannelFields,
249 /// The amount to push to the counterparty as part of the open, in milli-satoshi
251 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
252 pub channel_reserve_satoshis: u64,
255 /// An open_channel2 message to be sent by or received from the channel initiator.
257 /// Used in V2 channel establishment
259 // TODO(dual_funding): Add spec link for `open_channel2`.
260 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
261 pub struct OpenChannelV2 {
262 /// Common fields of `open_channel(2)`-like messages
263 pub common_fields: CommonOpenChannelFields,
264 /// The feerate for the funding transaction set by the channel initiator
265 pub funding_feerate_sat_per_1000_weight: u32,
266 /// The locktime for the funding transaction
268 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
269 pub second_per_commitment_point: PublicKey,
270 /// Optionally, a requirement that only confirmed inputs can be added
271 pub require_confirmed_inputs: Option<()>,
274 /// Contains fields that are both common to [`accept_channel`] and `accept_channel2` messages.
276 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
277 // TODO(dual_funding): Add spec link for `accept_channel2`.
278 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
279 pub struct CommonAcceptChannelFields {
280 /// The same `temporary_channel_id` received from the initiator's `open_channel2` or `open_channel` message.
281 pub temporary_channel_id: ChannelId,
282 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
284 pub dust_limit_satoshis: u64,
285 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
286 pub max_htlc_value_in_flight_msat: u64,
287 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
288 pub htlc_minimum_msat: u64,
289 /// Minimum depth of the funding transaction before the channel is considered open
290 pub minimum_depth: u32,
291 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
292 /// broadcast a commitment transaction
293 pub to_self_delay: u16,
294 /// The maximum number of inbound HTLCs towards channel acceptor
295 pub max_accepted_htlcs: u16,
296 /// The channel acceptor's key controlling the funding transaction
297 pub funding_pubkey: PublicKey,
298 /// Used to derive a revocation key for transactions broadcast by counterparty
299 pub revocation_basepoint: PublicKey,
300 /// A payment key to channel acceptor for transactions broadcast by counterparty
301 pub payment_basepoint: PublicKey,
302 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
304 pub delayed_payment_basepoint: PublicKey,
305 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
306 pub htlc_basepoint: PublicKey,
307 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
308 pub first_per_commitment_point: PublicKey,
309 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
310 /// collaboratively close
311 pub shutdown_scriptpubkey: Option<ScriptBuf>,
312 /// The channel type that this channel will represent. If none is set, we derive the channel
313 /// type from the intersection of our feature bits with our counterparty's feature bits from
314 /// the Init message.
316 /// This is required to match the equivalent field in [`OpenChannel`] or [`OpenChannelV2`]'s
317 /// [`CommonOpenChannelFields::channel_type`].
318 pub channel_type: Option<ChannelTypeFeatures>,
321 /// An [`accept_channel`] message to be sent to or received from a peer.
323 /// Used in V1 channel establishment
325 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
326 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
327 pub struct AcceptChannel {
328 /// Common fields of `accept_channel(2)`-like messages
329 pub common_fields: CommonAcceptChannelFields,
330 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
331 pub channel_reserve_satoshis: u64,
333 /// Next nonce the channel initiator should use to create a funding output signature against
334 pub next_local_nonce: Option<musig2::types::PublicNonce>,
337 /// An accept_channel2 message to be sent by or received from the channel accepter.
339 /// Used in V2 channel establishment
341 // TODO(dual_funding): Add spec link for `accept_channel2`.
342 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
343 pub struct AcceptChannelV2 {
344 /// Common fields of `accept_channel(2)`-like messages
345 pub common_fields: CommonAcceptChannelFields,
346 /// Part of the channel value contributed by the channel acceptor
347 pub funding_satoshis: u64,
348 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
349 pub second_per_commitment_point: PublicKey,
350 /// Optionally, a requirement that only confirmed inputs can be added
351 pub require_confirmed_inputs: Option<()>,
354 /// A [`funding_created`] message to be sent to or received from a peer.
356 /// Used in V1 channel establishment
358 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
359 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
360 pub struct FundingCreated {
361 /// A temporary channel ID, until the funding is established
362 pub temporary_channel_id: ChannelId,
363 /// The funding transaction ID
364 pub funding_txid: Txid,
365 /// The specific output index funding this channel
366 pub funding_output_index: u16,
367 /// The signature of the channel initiator (funder) on the initial commitment transaction
368 pub signature: Signature,
370 /// The partial signature of the channel initiator (funder)
371 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
373 /// Next nonce the channel acceptor should use to finalize the funding output signature
374 pub next_local_nonce: Option<musig2::types::PublicNonce>
377 /// A [`funding_signed`] message to be sent to or received from a peer.
379 /// Used in V1 channel establishment
381 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
382 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
383 pub struct FundingSigned {
385 pub channel_id: ChannelId,
386 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
387 pub signature: Signature,
389 /// The partial signature of the channel acceptor (fundee)
390 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
393 /// A [`channel_ready`] message to be sent to or received from a peer.
395 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
396 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
397 pub struct ChannelReady {
399 pub channel_id: ChannelId,
400 /// The per-commitment point of the second commitment transaction
401 pub next_per_commitment_point: PublicKey,
402 /// If set, provides a `short_channel_id` alias for this channel.
404 /// The sender will accept payments to be forwarded over this SCID and forward them to this
405 /// messages' recipient.
406 pub short_channel_id_alias: Option<u64>,
409 /// A randomly chosen number that is used to identify inputs within an interactive transaction
411 pub type SerialId = u64;
413 /// An `stfu` (quiescence) message to be sent by or received from the stfu initiator.
415 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/1160
416 #[derive(Clone, Debug, PartialEq, Eq)]
418 /// The channel ID where quiescence is intended
419 pub channel_id: ChannelId,
420 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
424 /// A `splice_init` message to be sent by or received from the stfu initiator (splice initiator).
426 // TODO(splicing): Add spec link for `splice_init`; still in draft, using from https://github.com/lightning/bolts/pull/1160
427 #[derive(Clone, Debug, PartialEq, Eq)]
428 pub struct SpliceInit {
429 /// The channel ID where splicing is intended
430 pub channel_id: ChannelId,
431 /// The amount the splice initiator is intending to add to its channel balance (splice-in)
432 /// or remove from its channel balance (splice-out).
433 pub funding_contribution_satoshis: i64,
434 /// The feerate for the new funding transaction, set by the splice initiator
435 pub funding_feerate_perkw: u32,
436 /// The locktime for the new funding transaction
438 /// The key of the sender (splice initiator) controlling the new funding transaction
439 pub funding_pubkey: PublicKey,
440 /// If set, only confirmed inputs added (by the splice acceptor) will be accepted
441 pub require_confirmed_inputs: Option<()>,
444 /// A `splice_ack` message to be received by or sent to the splice initiator.
446 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/1160
447 #[derive(Clone, Debug, PartialEq, Eq)]
448 pub struct SpliceAck {
449 /// The channel ID where splicing is intended
450 pub channel_id: ChannelId,
451 /// The amount the splice acceptor is intending to add to its channel balance (splice-in)
452 /// or remove from its channel balance (splice-out).
453 pub funding_contribution_satoshis: i64,
454 /// The key of the sender (splice acceptor) controlling the new funding transaction
455 pub funding_pubkey: PublicKey,
456 /// If set, only confirmed inputs added (by the splice initiator) will be accepted
457 pub require_confirmed_inputs: Option<()>,
460 /// A `splice_locked` message to be sent to or received from a peer.
462 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/1160
463 #[derive(Clone, Debug, PartialEq, Eq)]
464 pub struct SpliceLocked {
466 pub channel_id: ChannelId,
467 /// The ID of the new funding transaction that has been locked
468 pub splice_txid: Txid,
471 /// A tx_add_input message for adding an input during interactive transaction construction
473 // TODO(dual_funding): Add spec link for `tx_add_input`.
474 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
475 pub struct TxAddInput {
477 pub channel_id: ChannelId,
478 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
480 pub serial_id: SerialId,
481 /// Serialized transaction that contains the output this input spends to verify that it is non
483 pub prevtx: TransactionU16LenLimited,
484 /// The index of the output being spent
486 /// The sequence number of this input
488 /// The ID of the previous funding transaction, when it is being added as an input during splicing
489 pub shared_input_txid: Option<Txid>,
492 /// A tx_add_output message for adding an output during interactive transaction construction.
494 // TODO(dual_funding): Add spec link for `tx_add_output`.
495 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
496 pub struct TxAddOutput {
498 pub channel_id: ChannelId,
499 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
501 pub serial_id: SerialId,
502 /// The satoshi value of the output
504 /// The scriptPubKey for the output
505 pub script: ScriptBuf,
508 /// A tx_remove_input message for removing an input during interactive transaction construction.
510 // TODO(dual_funding): Add spec link for `tx_remove_input`.
511 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
512 pub struct TxRemoveInput {
514 pub channel_id: ChannelId,
515 /// The serial ID of the input to be removed
516 pub serial_id: SerialId,
519 /// A tx_remove_output message for removing an output during interactive transaction construction.
521 // TODO(dual_funding): Add spec link for `tx_remove_output`.
522 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
523 pub struct TxRemoveOutput {
525 pub channel_id: ChannelId,
526 /// The serial ID of the output to be removed
527 pub serial_id: SerialId,
530 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
531 /// interactive transaction construction.
533 // TODO(dual_funding): Add spec link for `tx_complete`.
534 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
535 pub struct TxComplete {
537 pub channel_id: ChannelId,
540 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
541 /// interactive transaction construction.
543 // TODO(dual_funding): Add spec link for `tx_signatures`.
544 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
545 pub struct TxSignatures {
547 pub channel_id: ChannelId,
550 /// The list of witnesses
551 pub witnesses: Vec<Witness>,
552 /// Optional signature for the shared input -- the previous funding outpoint -- signed by both peers
553 pub shared_input_signature: Option<Signature>,
556 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
559 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
560 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
561 pub struct TxInitRbf {
563 pub channel_id: ChannelId,
564 /// The locktime of the transaction
566 /// The feerate of the transaction
567 pub feerate_sat_per_1000_weight: u32,
568 /// The number of satoshis the sender will contribute to or, if negative, remove from
569 /// (e.g. splice-out) the funding output of the transaction
570 pub funding_output_contribution: Option<i64>,
573 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
576 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
577 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
578 pub struct TxAckRbf {
580 pub channel_id: ChannelId,
581 /// The number of satoshis the sender will contribute to or, if negative, remove from
582 /// (e.g. splice-out) the funding output of the transaction
583 pub funding_output_contribution: Option<i64>,
586 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
588 // TODO(dual_funding): Add spec link for `tx_abort`.
589 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
592 pub channel_id: ChannelId,
597 /// A [`shutdown`] message to be sent to or received from a peer.
599 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
600 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
601 pub struct Shutdown {
603 pub channel_id: ChannelId,
604 /// The destination of this peer's funds on closing.
606 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
607 pub scriptpubkey: ScriptBuf,
610 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
612 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
614 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
615 pub struct ClosingSignedFeeRange {
616 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
618 pub min_fee_satoshis: u64,
619 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
621 pub max_fee_satoshis: u64,
624 /// A [`closing_signed`] message to be sent to or received from a peer.
626 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
627 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
628 pub struct ClosingSigned {
630 pub channel_id: ChannelId,
631 /// The proposed total fee for the closing transaction
632 pub fee_satoshis: u64,
633 /// A signature on the closing transaction
634 pub signature: Signature,
635 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
637 pub fee_range: Option<ClosingSignedFeeRange>,
640 /// An [`update_add_htlc`] message to be sent to or received from a peer.
642 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
643 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
644 pub struct UpdateAddHTLC {
646 pub channel_id: ChannelId,
649 /// The HTLC value in milli-satoshi
650 pub amount_msat: u64,
651 /// The payment hash, the pre-image of which controls HTLC redemption
652 pub payment_hash: PaymentHash,
653 /// The expiry height of the HTLC
654 pub cltv_expiry: u32,
655 /// The extra fee skimmed by the sender of this message. See
656 /// [`ChannelConfig::accept_underpaying_htlcs`].
658 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
659 pub skimmed_fee_msat: Option<u64>,
660 /// The onion routing packet with encrypted data for the next hop.
661 pub onion_routing_packet: OnionPacket,
662 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
663 /// routing packet and the recipient-provided encrypted payload within.
664 pub blinding_point: Option<PublicKey>,
667 /// An onion message to be sent to or received from a peer.
669 // TODO: update with link to OM when they are merged into the BOLTs
670 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
671 pub struct OnionMessage {
672 /// Used in decrypting the onion packet's payload.
673 pub blinding_point: PublicKey,
674 /// The full onion packet including hop data, pubkey, and hmac
675 pub onion_routing_packet: onion_message::packet::Packet,
678 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
680 /// [`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
681 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
682 pub struct UpdateFulfillHTLC {
684 pub channel_id: ChannelId,
687 /// The pre-image of the payment hash, allowing HTLC redemption
688 pub payment_preimage: PaymentPreimage,
691 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
693 /// [`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
694 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
695 pub struct UpdateFailHTLC {
697 pub channel_id: ChannelId,
700 pub(crate) reason: OnionErrorPacket,
703 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
705 /// [`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
706 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
707 pub struct UpdateFailMalformedHTLC {
709 pub channel_id: ChannelId,
712 pub(crate) sha256_of_onion: [u8; 32],
714 pub failure_code: u16,
717 /// Optional batch parameters for `commitment_signed` message.
718 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
719 pub struct CommitmentSignedBatch {
720 /// Batch size N: all N `commitment_signed` messages must be received before being processed
722 /// The funding transaction, to discriminate among multiple pending funding transactions (e.g. in case of splicing)
723 pub funding_txid: Txid,
726 /// A [`commitment_signed`] message to be sent to or received from a peer.
728 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
729 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
730 pub struct CommitmentSigned {
732 pub channel_id: ChannelId,
733 /// A signature on the commitment transaction
734 pub signature: Signature,
735 /// Signatures on the HTLC transactions
736 pub htlc_signatures: Vec<Signature>,
737 /// Optional batch size and other parameters
738 pub batch: Option<CommitmentSignedBatch>,
740 /// The partial Taproot signature on the commitment transaction
741 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
744 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
746 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
747 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
748 pub struct RevokeAndACK {
750 pub channel_id: ChannelId,
751 /// The secret corresponding to the per-commitment point
752 pub per_commitment_secret: [u8; 32],
753 /// The next sender-broadcast commitment transaction's per-commitment point
754 pub next_per_commitment_point: PublicKey,
756 /// Musig nonce the recipient should use in their next commitment signature message
757 pub next_local_nonce: Option<musig2::types::PublicNonce>
760 /// An [`update_fee`] message to be sent to or received from a peer
762 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
763 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
764 pub struct UpdateFee {
766 pub channel_id: ChannelId,
767 /// Fee rate per 1000-weight of the transaction
768 pub feerate_per_kw: u32,
771 /// A [`channel_reestablish`] message to be sent to or received from a peer.
773 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
774 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
775 pub struct ChannelReestablish {
777 pub channel_id: ChannelId,
778 /// The next commitment number for the sender
779 pub next_local_commitment_number: u64,
780 /// The next commitment number for the recipient
781 pub next_remote_commitment_number: u64,
782 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
783 /// belonging to the recipient
784 pub your_last_per_commitment_secret: [u8; 32],
785 /// The sender's per-commitment point for their current commitment transaction
786 pub my_current_per_commitment_point: PublicKey,
787 /// The next funding transaction ID
788 pub next_funding_txid: Option<Txid>,
791 /// An [`announcement_signatures`] message to be sent to or received from a peer.
793 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
794 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
795 pub struct AnnouncementSignatures {
797 pub channel_id: ChannelId,
798 /// The short channel ID
799 pub short_channel_id: u64,
800 /// A signature by the node key
801 pub node_signature: Signature,
802 /// A signature by the funding key
803 pub bitcoin_signature: Signature,
806 /// An address which can be used to connect to a remote peer.
807 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
808 pub enum SocketAddress {
809 /// An IPv4 address and port on which the peer is listening.
811 /// The 4-byte IPv4 address
813 /// The port on which the node is listening
816 /// An IPv6 address and port on which the peer is listening.
818 /// The 16-byte IPv6 address
820 /// The port on which the node is listening
823 /// An old-style Tor onion address/port on which the peer is listening.
825 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
826 /// addresses. Thus, the details are not parsed here.
828 /// A new-style Tor onion address/port on which the peer is listening.
830 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
831 /// wrap as base32 and append ".onion".
833 /// The ed25519 long-term public key of the peer
834 ed25519_pubkey: [u8; 32],
835 /// The checksum of the pubkey and version, as included in the onion address
837 /// The version byte, as defined by the Tor Onion v3 spec.
839 /// The port on which the node is listening
842 /// A hostname/port on which the peer is listening.
844 /// The hostname on which the node is listening.
846 /// The port on which the node is listening.
851 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
853 pub(crate) fn get_id(&self) -> u8 {
855 &SocketAddress::TcpIpV4 {..} => { 1 },
856 &SocketAddress::TcpIpV6 {..} => { 2 },
857 &SocketAddress::OnionV2(_) => { 3 },
858 &SocketAddress::OnionV3 {..} => { 4 },
859 &SocketAddress::Hostname {..} => { 5 },
863 /// Strict byte-length of address descriptor, 1-byte type not recorded
864 fn len(&self) -> u16 {
866 &SocketAddress::TcpIpV4 { .. } => { 6 },
867 &SocketAddress::TcpIpV6 { .. } => { 18 },
868 &SocketAddress::OnionV2(_) => { 12 },
869 &SocketAddress::OnionV3 { .. } => { 37 },
870 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
871 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
875 /// The maximum length of any address descriptor, not including the 1-byte type.
876 /// This maximum length is reached by a hostname address descriptor:
877 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
878 pub(crate) const MAX_LEN: u16 = 258;
880 pub(crate) fn is_tor(&self) -> bool {
882 &SocketAddress::TcpIpV4 {..} => false,
883 &SocketAddress::TcpIpV6 {..} => false,
884 &SocketAddress::OnionV2(_) => true,
885 &SocketAddress::OnionV3 {..} => true,
886 &SocketAddress::Hostname {..} => false,
891 impl Writeable for SocketAddress {
892 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
894 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
899 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
904 &SocketAddress::OnionV2(bytes) => {
906 bytes.write(writer)?;
908 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
910 ed25519_pubkey.write(writer)?;
911 checksum.write(writer)?;
912 version.write(writer)?;
915 &SocketAddress::Hostname { ref hostname, ref port } => {
917 hostname.write(writer)?;
925 impl Readable for Result<SocketAddress, u8> {
926 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
927 let byte = <u8 as Readable>::read(reader)?;
930 Ok(Ok(SocketAddress::TcpIpV4 {
931 addr: Readable::read(reader)?,
932 port: Readable::read(reader)?,
936 Ok(Ok(SocketAddress::TcpIpV6 {
937 addr: Readable::read(reader)?,
938 port: Readable::read(reader)?,
941 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
943 Ok(Ok(SocketAddress::OnionV3 {
944 ed25519_pubkey: Readable::read(reader)?,
945 checksum: Readable::read(reader)?,
946 version: Readable::read(reader)?,
947 port: Readable::read(reader)?,
951 Ok(Ok(SocketAddress::Hostname {
952 hostname: Readable::read(reader)?,
953 port: Readable::read(reader)?,
956 _ => return Ok(Err(byte)),
961 impl Readable for SocketAddress {
962 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
963 match Readable::read(reader) {
964 Ok(Ok(res)) => Ok(res),
965 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
971 /// [`SocketAddress`] error variants
972 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
973 pub enum SocketAddressParseError {
974 /// Socket address (IPv4/IPv6) parsing error
976 /// Invalid input format
980 /// Invalid onion v3 address
984 impl fmt::Display for SocketAddressParseError {
985 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
987 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
988 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
989 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
990 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
991 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
996 #[cfg(feature = "std")]
997 impl From<std::net::SocketAddrV4> for SocketAddress {
998 fn from(addr: std::net::SocketAddrV4) -> Self {
999 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
1003 #[cfg(feature = "std")]
1004 impl From<std::net::SocketAddrV6> for SocketAddress {
1005 fn from(addr: std::net::SocketAddrV6) -> Self {
1006 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
1010 #[cfg(feature = "std")]
1011 impl From<std::net::SocketAddr> for SocketAddress {
1012 fn from(addr: std::net::SocketAddr) -> Self {
1014 std::net::SocketAddr::V4(addr) => addr.into(),
1015 std::net::SocketAddr::V6(addr) => addr.into(),
1020 #[cfg(feature = "std")]
1021 impl std::net::ToSocketAddrs for SocketAddress {
1022 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1024 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1026 SocketAddress::TcpIpV4 { addr, port } => {
1027 let ip_addr = std::net::Ipv4Addr::from(*addr);
1028 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1029 Ok(vec![socket_addr].into_iter())
1031 SocketAddress::TcpIpV6 { addr, port } => {
1032 let ip_addr = std::net::Ipv6Addr::from(*addr);
1033 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1034 Ok(vec![socket_addr].into_iter())
1036 SocketAddress::Hostname { ref hostname, port } => {
1037 (hostname.as_str(), *port).to_socket_addrs()
1039 SocketAddress::OnionV2(..) => {
1040 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1041 addresses is currently unsupported."))
1043 SocketAddress::OnionV3 { .. } => {
1044 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1045 addresses is currently unsupported."))
1051 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1053 /// The host part must end with ".onion".
1054 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1055 if host.ends_with(".onion") {
1056 let domain = &host[..host.len() - ".onion".len()];
1057 if domain.len() != 56 {
1058 return Err(SocketAddressParseError::InvalidOnionV3);
1060 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1061 if onion.len() != 35 {
1062 return Err(SocketAddressParseError::InvalidOnionV3);
1064 let version = onion[0];
1065 let first_checksum_flag = onion[1];
1066 let second_checksum_flag = onion[2];
1067 let mut ed25519_pubkey = [0; 32];
1068 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1069 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1070 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1073 return Err(SocketAddressParseError::InvalidInput);
1077 impl Display for SocketAddress {
1078 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1080 SocketAddress::TcpIpV4{addr, port} => write!(
1081 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1082 SocketAddress::TcpIpV6{addr, port} => write!(
1084 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1085 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7], addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15], port
1087 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1088 SocketAddress::OnionV3 {
1094 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1095 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1096 addr.extend_from_slice(ed25519_pubkey);
1097 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1098 write!(f, "{}.onion:{}", onion, port)?
1100 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1106 #[cfg(feature = "std")]
1107 impl FromStr for SocketAddress {
1108 type Err = SocketAddressParseError;
1110 fn from_str(s: &str) -> Result<Self, Self::Err> {
1111 match std::net::SocketAddr::from_str(s) {
1112 Ok(addr) => Ok(addr.into()),
1114 let trimmed_input = match s.rfind(":") {
1116 None => return Err(SocketAddressParseError::InvalidInput),
1118 let host = &s[..trimmed_input];
1119 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1120 if host.ends_with(".onion") {
1121 return parse_onion_address(host, port);
1123 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1124 return Ok(SocketAddress::Hostname { hostname, port });
1126 return Err(SocketAddressParseError::SocketAddrParse)
1132 /// Represents the set of gossip messages that require a signature from a node's identity key.
1133 pub enum UnsignedGossipMessage<'a> {
1134 /// An unsigned channel announcement.
1135 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1136 /// An unsigned channel update.
1137 ChannelUpdate(&'a UnsignedChannelUpdate),
1138 /// An unsigned node announcement.
1139 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1142 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1143 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1145 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1146 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1147 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1152 /// The unsigned part of a [`node_announcement`] message.
1154 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1155 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1156 pub struct UnsignedNodeAnnouncement {
1157 /// The advertised features
1158 pub features: NodeFeatures,
1159 /// A strictly monotonic announcement counter, with gaps allowed
1161 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1163 pub node_id: NodeId,
1164 /// An RGB color for UI purposes
1166 /// An alias, for UI purposes.
1168 /// This should be sanitized before use. There is no guarantee of uniqueness.
1169 pub alias: NodeAlias,
1170 /// List of addresses on which this node is reachable
1171 pub addresses: Vec<SocketAddress>,
1172 /// Excess address data which was signed as a part of the message which we do not (yet) understand how
1175 /// This is stored to ensure forward-compatibility as new address types are added to the lightning gossip protocol.
1176 pub excess_address_data: Vec<u8>,
1177 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1180 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1181 pub excess_data: Vec<u8>,
1183 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1184 /// A [`node_announcement`] message to be sent to or received from a peer.
1186 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1187 pub struct NodeAnnouncement {
1188 /// The signature by the node key
1189 pub signature: Signature,
1190 /// The actual content of the announcement
1191 pub contents: UnsignedNodeAnnouncement,
1194 /// The unsigned part of a [`channel_announcement`] message.
1196 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1197 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1198 pub struct UnsignedChannelAnnouncement {
1199 /// The advertised channel features
1200 pub features: ChannelFeatures,
1201 /// The genesis hash of the blockchain where the channel is to be opened
1202 pub chain_hash: ChainHash,
1203 /// The short channel ID
1204 pub short_channel_id: u64,
1205 /// One of the two `node_id`s which are endpoints of this channel
1206 pub node_id_1: NodeId,
1207 /// The other of the two `node_id`s which are endpoints of this channel
1208 pub node_id_2: NodeId,
1209 /// The funding key for the first node
1210 pub bitcoin_key_1: NodeId,
1211 /// The funding key for the second node
1212 pub bitcoin_key_2: NodeId,
1213 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1216 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1217 pub excess_data: Vec<u8>,
1219 /// A [`channel_announcement`] message to be sent to or received from a peer.
1221 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1222 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1223 pub struct ChannelAnnouncement {
1224 /// Authentication of the announcement by the first public node
1225 pub node_signature_1: Signature,
1226 /// Authentication of the announcement by the second public node
1227 pub node_signature_2: Signature,
1228 /// Proof of funding UTXO ownership by the first public node
1229 pub bitcoin_signature_1: Signature,
1230 /// Proof of funding UTXO ownership by the second public node
1231 pub bitcoin_signature_2: Signature,
1232 /// The actual announcement
1233 pub contents: UnsignedChannelAnnouncement,
1236 /// The unsigned part of a [`channel_update`] message.
1238 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1239 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1240 pub struct UnsignedChannelUpdate {
1241 /// The genesis hash of the blockchain where the channel is to be opened
1242 pub chain_hash: ChainHash,
1243 /// The short channel ID
1244 pub short_channel_id: u64,
1245 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1247 /// Flags pertaining to this message.
1248 pub message_flags: u8,
1249 /// Flags pertaining to the channel, including to which direction in the channel this update
1250 /// applies and whether the direction is currently able to forward HTLCs.
1251 pub channel_flags: u8,
1252 /// The number of blocks such that if:
1253 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1254 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1255 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1256 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1257 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1258 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1259 /// constructing the route.
1260 pub cltv_expiry_delta: u16,
1261 /// The minimum HTLC size incoming to sender, in milli-satoshi
1262 pub htlc_minimum_msat: u64,
1263 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1265 /// This used to be optional.
1266 pub htlc_maximum_msat: u64,
1267 /// The base HTLC fee charged by sender, in milli-satoshi
1268 pub fee_base_msat: u32,
1269 /// The amount to fee multiplier, in micro-satoshi
1270 pub fee_proportional_millionths: u32,
1271 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1274 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1275 pub excess_data: Vec<u8>,
1277 /// A [`channel_update`] message to be sent to or received from a peer.
1279 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1280 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1281 pub struct ChannelUpdate {
1282 /// A signature of the channel update
1283 pub signature: Signature,
1284 /// The actual channel update
1285 pub contents: UnsignedChannelUpdate,
1288 /// A [`query_channel_range`] message is used to query a peer for channel
1289 /// UTXOs in a range of blocks. The recipient of a query makes a best
1290 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1293 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1294 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1295 pub struct QueryChannelRange {
1296 /// The genesis hash of the blockchain being queried
1297 pub chain_hash: ChainHash,
1298 /// The height of the first block for the channel UTXOs being queried
1299 pub first_blocknum: u32,
1300 /// The number of blocks to include in the query results
1301 pub number_of_blocks: u32,
1304 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1307 /// Multiple `reply_channel_range` messages can be sent in reply
1308 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1309 /// best effort to respond based on their local network view which may
1310 /// not be a perfect view of the network. The `short_channel_id`s in the
1311 /// reply are encoded. We only support `encoding_type=0` uncompressed
1312 /// serialization and do not support `encoding_type=1` zlib serialization.
1314 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1315 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1316 pub struct ReplyChannelRange {
1317 /// The genesis hash of the blockchain being queried
1318 pub chain_hash: ChainHash,
1319 /// The height of the first block in the range of the reply
1320 pub first_blocknum: u32,
1321 /// The number of blocks included in the range of the reply
1322 pub number_of_blocks: u32,
1323 /// True when this is the final reply for a query
1324 pub sync_complete: bool,
1325 /// The `short_channel_id`s in the channel range
1326 pub short_channel_ids: Vec<u64>,
1329 /// A [`query_short_channel_ids`] message is used to query a peer for
1330 /// routing gossip messages related to one or more `short_channel_id`s.
1332 /// The query recipient will reply with the latest, if available,
1333 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1334 /// it maintains for the requested `short_channel_id`s followed by a
1335 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1336 /// this query are encoded. We only support `encoding_type=0` uncompressed
1337 /// serialization and do not support `encoding_type=1` zlib serialization.
1339 /// [`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
1340 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1341 pub struct QueryShortChannelIds {
1342 /// The genesis hash of the blockchain being queried
1343 pub chain_hash: ChainHash,
1344 /// The short_channel_ids that are being queried
1345 pub short_channel_ids: Vec<u64>,
1348 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1349 /// message. The query recipient makes a best
1350 /// effort to respond based on their local network view which may not be
1351 /// a perfect view of the network.
1353 /// [`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
1354 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1355 pub struct ReplyShortChannelIdsEnd {
1356 /// The genesis hash of the blockchain that was queried
1357 pub chain_hash: ChainHash,
1358 /// Indicates if the query recipient maintains up-to-date channel
1359 /// information for the `chain_hash`
1360 pub full_information: bool,
1363 /// A [`gossip_timestamp_filter`] message is used by a node to request
1364 /// gossip relay for messages in the requested time range when the
1365 /// `gossip_queries` feature has been negotiated.
1367 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1368 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1369 pub struct GossipTimestampFilter {
1370 /// The genesis hash of the blockchain for channel and node information
1371 pub chain_hash: ChainHash,
1372 /// The starting unix timestamp
1373 pub first_timestamp: u32,
1374 /// The range of information in seconds
1375 pub timestamp_range: u32,
1378 /// Encoding type for data compression of collections in gossip queries.
1380 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1381 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1383 Uncompressed = 0x00,
1386 /// Used to put an error message in a [`LightningError`].
1387 #[derive(Clone, Debug, Hash, PartialEq)]
1388 pub enum ErrorAction {
1389 /// The peer took some action which made us think they were useless. Disconnect them.
1391 /// An error message which we should make an effort to send before we disconnect.
1392 msg: Option<ErrorMessage>
1394 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1395 DisconnectPeerWithWarning {
1396 /// A warning message which we should make an effort to send before we disconnect.
1397 msg: WarningMessage,
1399 /// The peer did something harmless that we weren't able to process, just log and ignore
1400 // New code should *not* use this. New code must use IgnoreAndLog, below!
1402 /// The peer did something harmless that we weren't able to meaningfully process.
1403 /// If the error is logged, log it at the given level.
1404 IgnoreAndLog(logger::Level),
1405 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1406 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1407 /// our own channel announcements.
1408 IgnoreDuplicateGossip,
1409 /// The peer did something incorrect. Tell them.
1411 /// The message to send.
1414 /// The peer did something incorrect. Tell them without closing any channels.
1415 SendWarningMessage {
1416 /// The message to send.
1417 msg: WarningMessage,
1418 /// The peer may have done something harmless that we weren't able to meaningfully process,
1419 /// though we should still tell them about it.
1420 /// If this event is logged, log it at the given level.
1421 log_level: logger::Level,
1425 /// An Err type for failure to process messages.
1426 #[derive(Clone, Debug)]
1427 pub struct LightningError {
1428 /// A human-readable message describing the error
1430 /// The action which should be taken against the offending peer.
1431 pub action: ErrorAction,
1434 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1435 /// transaction updates if they were pending.
1436 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1437 pub struct CommitmentUpdate {
1438 /// `update_add_htlc` messages which should be sent
1439 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1440 /// `update_fulfill_htlc` messages which should be sent
1441 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1442 /// `update_fail_htlc` messages which should be sent
1443 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1444 /// `update_fail_malformed_htlc` messages which should be sent
1445 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1446 /// An `update_fee` message which should be sent
1447 pub update_fee: Option<UpdateFee>,
1448 /// A `commitment_signed` message which should be sent
1449 pub commitment_signed: CommitmentSigned,
1452 /// A trait to describe an object which can receive channel messages.
1454 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1455 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1456 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1458 /// Handle an incoming `open_channel` message from the given peer.
1459 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1460 /// Handle an incoming `open_channel2` message from the given peer.
1461 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1462 /// Handle an incoming `accept_channel` message from the given peer.
1463 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1464 /// Handle an incoming `accept_channel2` message from the given peer.
1465 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1466 /// Handle an incoming `funding_created` message from the given peer.
1467 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1468 /// Handle an incoming `funding_signed` message from the given peer.
1469 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1470 /// Handle an incoming `channel_ready` message from the given peer.
1471 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1474 /// Handle an incoming `shutdown` message from the given peer.
1475 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1476 /// Handle an incoming `closing_signed` message from the given peer.
1477 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1480 /// Handle an incoming `stfu` message from the given peer.
1481 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1484 /// Handle an incoming `splice_init` message from the given peer.
1486 fn handle_splice_init(&self, their_node_id: &PublicKey, msg: &SpliceInit);
1487 /// Handle an incoming `splice_ack` message from the given peer.
1489 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1490 /// Handle an incoming `splice_locked` message from the given peer.
1492 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1494 // Interactive channel construction
1495 /// Handle an incoming `tx_add_input message` from the given peer.
1496 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1497 /// Handle an incoming `tx_add_output` message from the given peer.
1498 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1499 /// Handle an incoming `tx_remove_input` message from the given peer.
1500 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1501 /// Handle an incoming `tx_remove_output` message from the given peer.
1502 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1503 /// Handle an incoming `tx_complete message` from the given peer.
1504 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1505 /// Handle an incoming `tx_signatures` message from the given peer.
1506 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1507 /// Handle an incoming `tx_init_rbf` message from the given peer.
1508 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1509 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1510 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1511 /// Handle an incoming `tx_abort message` from the given peer.
1512 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1515 /// Handle an incoming `update_add_htlc` message from the given peer.
1516 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1517 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1518 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1519 /// Handle an incoming `update_fail_htlc` message from the given peer.
1520 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1521 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1522 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1523 /// Handle an incoming `commitment_signed` message from the given peer.
1524 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1525 /// Handle an incoming `revoke_and_ack` message from the given peer.
1526 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1528 /// Handle an incoming `update_fee` message from the given peer.
1529 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1531 // Channel-to-announce:
1532 /// Handle an incoming `announcement_signatures` message from the given peer.
1533 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1535 // Connection loss/reestablish:
1536 /// Indicates a connection to the peer failed/an existing connection was lost.
1537 fn peer_disconnected(&self, their_node_id: &PublicKey);
1539 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1541 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1542 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1543 /// message handlers may still wish to communicate with this peer.
1544 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1545 /// Handle an incoming `channel_reestablish` message from the given peer.
1546 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1548 /// Handle an incoming `channel_update` message from the given peer.
1549 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1552 /// Handle an incoming `error` message from the given peer.
1553 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1555 // Handler information:
1556 /// Gets the node feature flags which this handler itself supports. All available handlers are
1557 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1558 /// which are broadcasted in our [`NodeAnnouncement`] message.
1559 fn provided_node_features(&self) -> NodeFeatures;
1561 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1562 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1563 /// which are sent in our [`Init`] message.
1565 /// Note that this method is called before [`Self::peer_connected`].
1566 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1568 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1570 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1571 /// connecting to peers.
1572 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1575 /// A trait to describe an object which can receive routing messages.
1577 /// # Implementor DoS Warnings
1579 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1580 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1581 /// repeated disk I/O for queries accessing different parts of the network graph.
1582 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1583 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1584 /// `false` or returning an `Err` otherwise.
1585 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1586 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1587 /// or returning an `Err` otherwise.
1588 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1589 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1590 /// `false` or returning an `Err` otherwise.
1591 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1592 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1593 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1594 /// for a single channel.
1595 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1596 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1597 /// the node *after* the provided pubkey and including up to one announcement immediately
1598 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1599 /// If `None` is provided for `starting_point`, we start at the first node.
1600 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1601 /// Called when a connection is established with a peer. This can be used to
1602 /// perform routing table synchronization using a strategy defined by the
1605 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1606 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1607 /// message handlers may still wish to communicate with this peer.
1608 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1609 /// Handles the reply of a query we initiated to learn about channels
1610 /// for a given range of blocks. We can expect to receive one or more
1611 /// replies to a single query.
1612 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1613 /// Handles the reply of a query we initiated asking for routing gossip
1614 /// messages for a list of channels. We should receive this message when
1615 /// a node has completed its best effort to send us the pertaining routing
1616 /// gossip messages.
1617 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1618 /// Handles when a peer asks us to send a list of `short_channel_id`s
1619 /// for the requested range of blocks.
1620 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1621 /// Handles when a peer asks us to send routing gossip messages for a
1622 /// list of `short_channel_id`s.
1623 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1625 // Handler queueing status:
1626 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1627 /// pending some async action. While there is no guarantee of the rate of future messages, the
1628 /// caller should seek to reduce the rate of new gossip messages handled, especially
1629 /// [`ChannelAnnouncement`]s.
1630 fn processing_queue_high(&self) -> bool;
1632 // Handler information:
1633 /// Gets the node feature flags which this handler itself supports. All available handlers are
1634 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1635 /// which are broadcasted in our [`NodeAnnouncement`] message.
1636 fn provided_node_features(&self) -> NodeFeatures;
1637 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1638 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1639 /// which are sent in our [`Init`] message.
1641 /// Note that this method is called before [`Self::peer_connected`].
1642 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1645 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1646 pub trait OnionMessageHandler {
1647 /// Handle an incoming `onion_message` message from the given peer.
1648 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1650 /// Returns the next pending onion message for the peer with the given node id.
1651 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1653 /// Called when a connection is established with a peer. Can be used to track which peers
1654 /// advertise onion message support and are online.
1656 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1657 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1658 /// message handlers may still wish to communicate with this peer.
1659 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1661 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1662 /// drop and refuse to forward onion messages to this peer.
1663 fn peer_disconnected(&self, their_node_id: &PublicKey);
1665 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1666 /// to drop any buffered onion messages intended for prospective peers.
1667 fn timer_tick_occurred(&self);
1669 // Handler information:
1670 /// Gets the node feature flags which this handler itself supports. All available handlers are
1671 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1672 /// which are broadcasted in our [`NodeAnnouncement`] message.
1673 fn provided_node_features(&self) -> NodeFeatures;
1675 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1676 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1677 /// which are sent in our [`Init`] message.
1679 /// Note that this method is called before [`Self::peer_connected`].
1680 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1684 #[cfg_attr(test, derive(Debug, PartialEq))]
1685 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1686 /// the payment is associated with an invoice.
1687 pub struct FinalOnionHopData {
1688 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1689 /// Because it is generated by the recipient and included in the invoice, it also provides
1690 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1691 pub payment_secret: PaymentSecret,
1692 /// The intended total amount that this payment is for.
1694 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1695 pub total_msat: u64,
1698 mod fuzzy_internal_msgs {
1699 use bitcoin::secp256k1::PublicKey;
1700 use crate::blinded_path::payment::{PaymentConstraints, PaymentContext, PaymentRelay};
1701 use crate::ln::types::{PaymentPreimage, PaymentSecret};
1702 use crate::ln::features::BlindedHopFeatures;
1703 use super::{FinalOnionHopData, TrampolineOnionPacket};
1705 #[allow(unused_imports)]
1706 use crate::prelude::*;
1708 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1709 // them from untrusted input):
1711 pub enum InboundOnionPayload {
1713 short_channel_id: u64,
1714 /// The value, in msat, of the payment after this hop's fee is deducted.
1715 amt_to_forward: u64,
1716 outgoing_cltv_value: u32,
1719 payment_data: Option<FinalOnionHopData>,
1720 payment_metadata: Option<Vec<u8>>,
1721 keysend_preimage: Option<PaymentPreimage>,
1722 custom_tlvs: Vec<(u64, Vec<u8>)>,
1723 sender_intended_htlc_amt_msat: u64,
1724 cltv_expiry_height: u32,
1727 short_channel_id: u64,
1728 payment_relay: PaymentRelay,
1729 payment_constraints: PaymentConstraints,
1730 features: BlindedHopFeatures,
1731 intro_node_blinding_point: Option<PublicKey>,
1734 sender_intended_htlc_amt_msat: u64,
1736 cltv_expiry_height: u32,
1737 payment_secret: PaymentSecret,
1738 payment_constraints: PaymentConstraints,
1739 payment_context: PaymentContext,
1740 intro_node_blinding_point: Option<PublicKey>,
1741 keysend_preimage: Option<PaymentPreimage>,
1742 custom_tlvs: Vec<(u64, Vec<u8>)>,
1746 pub(crate) enum OutboundOnionPayload<'a> {
1748 short_channel_id: u64,
1749 /// The value, in msat, of the payment after this hop's fee is deducted.
1750 amt_to_forward: u64,
1751 outgoing_cltv_value: u32,
1754 TrampolineEntrypoint {
1755 amt_to_forward: u64,
1756 outgoing_cltv_value: u32,
1757 multipath_trampoline_data: Option<FinalOnionHopData>,
1758 trampoline_packet: TrampolineOnionPacket,
1761 payment_data: Option<FinalOnionHopData>,
1762 payment_metadata: Option<&'a Vec<u8>>,
1763 keysend_preimage: Option<PaymentPreimage>,
1764 custom_tlvs: &'a Vec<(u64, Vec<u8>)>,
1765 sender_intended_htlc_amt_msat: u64,
1766 cltv_expiry_height: u32,
1769 encrypted_tlvs: &'a Vec<u8>,
1770 intro_node_blinding_point: Option<PublicKey>,
1773 sender_intended_htlc_amt_msat: u64,
1775 cltv_expiry_height: u32,
1776 encrypted_tlvs: &'a Vec<u8>,
1777 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1778 keysend_preimage: Option<PaymentPreimage>,
1779 custom_tlvs: &'a Vec<(u64, Vec<u8>)>,
1783 pub(crate) enum OutboundTrampolinePayload {
1786 /// The value, in msat, of the payment after this hop's fee is deducted.
1787 amt_to_forward: u64,
1788 outgoing_cltv_value: u32,
1789 /// The node id to which the trampoline node must find a route
1790 outgoing_node_id: PublicKey,
1794 pub struct DecodedOnionErrorPacket {
1795 pub(crate) hmac: [u8; 32],
1796 pub(crate) failuremsg: Vec<u8>,
1797 pub(crate) pad: Vec<u8>,
1801 pub use self::fuzzy_internal_msgs::*;
1802 #[cfg(not(fuzzing))]
1803 pub(crate) use self::fuzzy_internal_msgs::*;
1805 /// BOLT 4 onion packet including hop data for the next peer.
1806 #[derive(Clone, Hash, PartialEq, Eq)]
1807 pub struct OnionPacket {
1808 /// BOLT 4 version number.
1810 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1811 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1812 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1813 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1815 pub public_key: Result<PublicKey, secp256k1::Error>,
1816 /// 1300 bytes encrypted payload for the next hop.
1817 pub hop_data: [u8; 20*65],
1818 /// HMAC to verify the integrity of hop_data.
1822 impl onion_utils::Packet for OnionPacket {
1823 type Data = onion_utils::FixedSizeOnionPacket;
1824 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1827 public_key: Ok(pubkey),
1828 hop_data: hop_data.0,
1834 impl fmt::Debug for OnionPacket {
1835 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1836 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1840 /// BOLT 4 onion packet including hop data for the next peer.
1841 #[derive(Clone, Hash, PartialEq, Eq)]
1842 pub struct TrampolineOnionPacket {
1843 /// Bolt 04 version number
1845 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1846 pub public_key: PublicKey,
1847 /// Encrypted payload for the next hop
1849 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1850 // 1300 bytes. The expected default is 650 bytes.
1851 // TODO: if 650 ends up being the most common size, optimize this to be:
1852 // enum { SixFifty([u8; 650]), VarLen(Vec<u8>) }
1853 pub hop_data: Vec<u8>,
1854 /// HMAC to verify the integrity of hop_data
1858 impl onion_utils::Packet for TrampolineOnionPacket {
1859 type Data = Vec<u8>;
1860 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1870 impl Writeable for TrampolineOnionPacket {
1871 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1872 self.version.write(w)?;
1873 self.public_key.write(w)?;
1874 w.write_all(&self.hop_data)?;
1875 self.hmac.write(w)?;
1880 impl LengthReadable for TrampolineOnionPacket {
1881 fn read<R: LengthRead>(r: &mut R) -> Result<Self, DecodeError> {
1882 let version = Readable::read(r)?;
1883 let public_key = Readable::read(r)?;
1885 let hop_data_len = r.total_bytes().saturating_sub(66); // 1 (version) + 33 (pubkey) + 32 (HMAC) = 66
1886 let mut rd = FixedLengthReader::new(r, hop_data_len);
1887 let hop_data = WithoutLength::<Vec<u8>>::read(&mut rd)?.0;
1889 let hmac = Readable::read(r)?;
1891 Ok(TrampolineOnionPacket {
1900 impl Debug for TrampolineOnionPacket {
1901 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1902 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1906 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1907 pub(crate) struct OnionErrorPacket {
1908 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1909 // (TODO) We limit it in decode to much lower...
1910 pub(crate) data: Vec<u8>,
1913 impl fmt::Display for DecodeError {
1914 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1916 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1917 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1918 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1919 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1920 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1921 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1922 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1923 DecodeError::DangerousValue => f.write_str("Value would be dangerous to continue execution with"),
1928 impl From<io::Error> for DecodeError {
1929 fn from(e: io::Error) -> Self {
1930 if e.kind() == io::ErrorKind::UnexpectedEof {
1931 DecodeError::ShortRead
1933 DecodeError::Io(e.kind())
1938 impl Writeable for AcceptChannel {
1939 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1940 self.common_fields.temporary_channel_id.write(w)?;
1941 self.common_fields.dust_limit_satoshis.write(w)?;
1942 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1943 self.channel_reserve_satoshis.write(w)?;
1944 self.common_fields.htlc_minimum_msat.write(w)?;
1945 self.common_fields.minimum_depth.write(w)?;
1946 self.common_fields.to_self_delay.write(w)?;
1947 self.common_fields.max_accepted_htlcs.write(w)?;
1948 self.common_fields.funding_pubkey.write(w)?;
1949 self.common_fields.revocation_basepoint.write(w)?;
1950 self.common_fields.payment_basepoint.write(w)?;
1951 self.common_fields.delayed_payment_basepoint.write(w)?;
1952 self.common_fields.htlc_basepoint.write(w)?;
1953 self.common_fields.first_per_commitment_point.write(w)?;
1954 #[cfg(not(taproot))]
1955 encode_tlv_stream!(w, {
1956 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1957 (1, self.common_fields.channel_type, option),
1960 encode_tlv_stream!(w, {
1961 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1962 (1, self.common_fields.channel_type, option),
1963 (4, self.next_local_nonce, option),
1969 impl Readable for AcceptChannel {
1970 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1971 let temporary_channel_id: ChannelId = Readable::read(r)?;
1972 let dust_limit_satoshis: u64 = Readable::read(r)?;
1973 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1974 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1975 let htlc_minimum_msat: u64 = Readable::read(r)?;
1976 let minimum_depth: u32 = Readable::read(r)?;
1977 let to_self_delay: u16 = Readable::read(r)?;
1978 let max_accepted_htlcs: u16 = Readable::read(r)?;
1979 let funding_pubkey: PublicKey = Readable::read(r)?;
1980 let revocation_basepoint: PublicKey = Readable::read(r)?;
1981 let payment_basepoint: PublicKey = Readable::read(r)?;
1982 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1983 let htlc_basepoint: PublicKey = Readable::read(r)?;
1984 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1986 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1987 let mut channel_type: Option<ChannelTypeFeatures> = None;
1988 #[cfg(not(taproot))]
1989 decode_tlv_stream!(r, {
1990 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1991 (1, channel_type, option),
1994 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1996 decode_tlv_stream!(r, {
1997 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1998 (1, channel_type, option),
1999 (4, next_local_nonce, option),
2003 common_fields: CommonAcceptChannelFields {
2004 temporary_channel_id,
2005 dust_limit_satoshis,
2006 max_htlc_value_in_flight_msat,
2012 revocation_basepoint,
2014 delayed_payment_basepoint,
2016 first_per_commitment_point,
2017 shutdown_scriptpubkey,
2020 channel_reserve_satoshis,
2027 impl Writeable for AcceptChannelV2 {
2028 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2029 self.common_fields.temporary_channel_id.write(w)?;
2030 self.funding_satoshis.write(w)?;
2031 self.common_fields.dust_limit_satoshis.write(w)?;
2032 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2033 self.common_fields.htlc_minimum_msat.write(w)?;
2034 self.common_fields.minimum_depth.write(w)?;
2035 self.common_fields.to_self_delay.write(w)?;
2036 self.common_fields.max_accepted_htlcs.write(w)?;
2037 self.common_fields.funding_pubkey.write(w)?;
2038 self.common_fields.revocation_basepoint.write(w)?;
2039 self.common_fields.payment_basepoint.write(w)?;
2040 self.common_fields.delayed_payment_basepoint.write(w)?;
2041 self.common_fields.htlc_basepoint.write(w)?;
2042 self.common_fields.first_per_commitment_point.write(w)?;
2043 self.second_per_commitment_point.write(w)?;
2045 encode_tlv_stream!(w, {
2046 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2047 (1, self.common_fields.channel_type, option),
2048 (2, self.require_confirmed_inputs, option),
2054 impl Readable for AcceptChannelV2 {
2055 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2056 let temporary_channel_id: ChannelId = Readable::read(r)?;
2057 let funding_satoshis: u64 = Readable::read(r)?;
2058 let dust_limit_satoshis: u64 = Readable::read(r)?;
2059 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2060 let htlc_minimum_msat: u64 = Readable::read(r)?;
2061 let minimum_depth: u32 = Readable::read(r)?;
2062 let to_self_delay: u16 = Readable::read(r)?;
2063 let max_accepted_htlcs: u16 = Readable::read(r)?;
2064 let funding_pubkey: PublicKey = Readable::read(r)?;
2065 let revocation_basepoint: PublicKey = Readable::read(r)?;
2066 let payment_basepoint: PublicKey = Readable::read(r)?;
2067 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2068 let htlc_basepoint: PublicKey = Readable::read(r)?;
2069 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2070 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2072 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2073 let mut channel_type: Option<ChannelTypeFeatures> = None;
2074 let mut require_confirmed_inputs: Option<()> = None;
2075 decode_tlv_stream!(r, {
2076 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2077 (1, channel_type, option),
2078 (2, require_confirmed_inputs, option),
2081 Ok(AcceptChannelV2 {
2082 common_fields: CommonAcceptChannelFields {
2083 temporary_channel_id,
2084 dust_limit_satoshis,
2085 max_htlc_value_in_flight_msat,
2091 revocation_basepoint,
2093 delayed_payment_basepoint,
2095 first_per_commitment_point,
2096 shutdown_scriptpubkey,
2100 second_per_commitment_point,
2101 require_confirmed_inputs,
2106 impl_writeable_msg!(Stfu, {
2111 impl_writeable_msg!(SpliceInit, {
2113 funding_contribution_satoshis,
2114 funding_feerate_perkw,
2118 (2, require_confirmed_inputs, option), // `splice_init_tlvs`
2121 impl_writeable_msg!(SpliceAck, {
2123 funding_contribution_satoshis,
2126 (2, require_confirmed_inputs, option), // `splice_ack_tlvs`
2129 impl_writeable_msg!(SpliceLocked, {
2134 impl_writeable_msg!(TxAddInput, {
2141 (0, shared_input_txid, option), // `funding_txid`
2144 impl_writeable_msg!(TxAddOutput, {
2151 impl_writeable_msg!(TxRemoveInput, {
2156 impl_writeable_msg!(TxRemoveOutput, {
2161 impl_writeable_msg!(TxComplete, {
2165 impl_writeable_msg!(TxSignatures, {
2170 (0, shared_input_signature, option), // `signature`
2173 impl_writeable_msg!(TxInitRbf, {
2176 feerate_sat_per_1000_weight,
2178 (0, funding_output_contribution, option),
2181 impl_writeable_msg!(TxAckRbf, {
2184 (0, funding_output_contribution, option),
2187 impl_writeable_msg!(TxAbort, {
2192 impl_writeable_msg!(AnnouncementSignatures, {
2199 impl_writeable_msg!(ChannelReestablish, {
2201 next_local_commitment_number,
2202 next_remote_commitment_number,
2203 your_last_per_commitment_secret,
2204 my_current_per_commitment_point,
2206 (0, next_funding_txid, option),
2209 impl_writeable_msg!(ClosingSigned,
2210 { channel_id, fee_satoshis, signature },
2211 { (1, fee_range, option) }
2214 impl_writeable!(ClosingSignedFeeRange, {
2219 impl_writeable_msg!(CommitmentSignedBatch, {
2224 #[cfg(not(taproot))]
2225 impl_writeable_msg!(CommitmentSigned, {
2234 impl_writeable_msg!(CommitmentSigned, {
2240 (2, partial_signature_with_nonce, option),
2243 impl_writeable!(DecodedOnionErrorPacket, {
2249 #[cfg(not(taproot))]
2250 impl_writeable_msg!(FundingCreated, {
2251 temporary_channel_id,
2253 funding_output_index,
2257 impl_writeable_msg!(FundingCreated, {
2258 temporary_channel_id,
2260 funding_output_index,
2263 (2, partial_signature_with_nonce, option),
2264 (4, next_local_nonce, option)
2267 #[cfg(not(taproot))]
2268 impl_writeable_msg!(FundingSigned, {
2274 impl_writeable_msg!(FundingSigned, {
2278 (2, partial_signature_with_nonce, option)
2281 impl_writeable_msg!(ChannelReady, {
2283 next_per_commitment_point,
2285 (1, short_channel_id_alias, option),
2288 impl Writeable for Init {
2289 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2290 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2291 // our relevant feature bits. This keeps us compatible with old nodes.
2292 self.features.write_up_to_13(w)?;
2293 self.features.write(w)?;
2294 encode_tlv_stream!(w, {
2295 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2296 (3, self.remote_network_address, option),
2302 impl Readable for Init {
2303 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2304 let global_features: InitFeatures = Readable::read(r)?;
2305 let features: InitFeatures = Readable::read(r)?;
2306 let mut remote_network_address: Option<SocketAddress> = None;
2307 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2308 decode_tlv_stream!(r, {
2309 (1, networks, option),
2310 (3, remote_network_address, option)
2313 features: features | global_features,
2314 networks: networks.map(|n| n.0),
2315 remote_network_address,
2320 impl Writeable for OpenChannel {
2321 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2322 self.common_fields.chain_hash.write(w)?;
2323 self.common_fields.temporary_channel_id.write(w)?;
2324 self.common_fields.funding_satoshis.write(w)?;
2325 self.push_msat.write(w)?;
2326 self.common_fields.dust_limit_satoshis.write(w)?;
2327 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2328 self.channel_reserve_satoshis.write(w)?;
2329 self.common_fields.htlc_minimum_msat.write(w)?;
2330 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2331 self.common_fields.to_self_delay.write(w)?;
2332 self.common_fields.max_accepted_htlcs.write(w)?;
2333 self.common_fields.funding_pubkey.write(w)?;
2334 self.common_fields.revocation_basepoint.write(w)?;
2335 self.common_fields.payment_basepoint.write(w)?;
2336 self.common_fields.delayed_payment_basepoint.write(w)?;
2337 self.common_fields.htlc_basepoint.write(w)?;
2338 self.common_fields.first_per_commitment_point.write(w)?;
2339 self.common_fields.channel_flags.write(w)?;
2340 encode_tlv_stream!(w, {
2341 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2342 (1, self.common_fields.channel_type, option),
2348 impl Readable for OpenChannel {
2349 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2350 let chain_hash: ChainHash = Readable::read(r)?;
2351 let temporary_channel_id: ChannelId = Readable::read(r)?;
2352 let funding_satoshis: u64 = Readable::read(r)?;
2353 let push_msat: u64 = Readable::read(r)?;
2354 let dust_limit_satoshis: u64 = Readable::read(r)?;
2355 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2356 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2357 let htlc_minimum_msat: u64 = Readable::read(r)?;
2358 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2359 let to_self_delay: u16 = Readable::read(r)?;
2360 let max_accepted_htlcs: u16 = Readable::read(r)?;
2361 let funding_pubkey: PublicKey = Readable::read(r)?;
2362 let revocation_basepoint: PublicKey = Readable::read(r)?;
2363 let payment_basepoint: PublicKey = Readable::read(r)?;
2364 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2365 let htlc_basepoint: PublicKey = Readable::read(r)?;
2366 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2367 let channel_flags: u8 = Readable::read(r)?;
2369 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2370 let mut channel_type: Option<ChannelTypeFeatures> = None;
2371 decode_tlv_stream!(r, {
2372 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2373 (1, channel_type, option),
2376 common_fields: CommonOpenChannelFields {
2378 temporary_channel_id,
2380 dust_limit_satoshis,
2381 max_htlc_value_in_flight_msat,
2383 commitment_feerate_sat_per_1000_weight,
2387 revocation_basepoint,
2389 delayed_payment_basepoint,
2391 first_per_commitment_point,
2393 shutdown_scriptpubkey,
2397 channel_reserve_satoshis,
2402 impl Writeable for OpenChannelV2 {
2403 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2404 self.common_fields.chain_hash.write(w)?;
2405 self.common_fields.temporary_channel_id.write(w)?;
2406 self.funding_feerate_sat_per_1000_weight.write(w)?;
2407 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2408 self.common_fields.funding_satoshis.write(w)?;
2409 self.common_fields.dust_limit_satoshis.write(w)?;
2410 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2411 self.common_fields.htlc_minimum_msat.write(w)?;
2412 self.common_fields.to_self_delay.write(w)?;
2413 self.common_fields.max_accepted_htlcs.write(w)?;
2414 self.locktime.write(w)?;
2415 self.common_fields.funding_pubkey.write(w)?;
2416 self.common_fields.revocation_basepoint.write(w)?;
2417 self.common_fields.payment_basepoint.write(w)?;
2418 self.common_fields.delayed_payment_basepoint.write(w)?;
2419 self.common_fields.htlc_basepoint.write(w)?;
2420 self.common_fields.first_per_commitment_point.write(w)?;
2421 self.second_per_commitment_point.write(w)?;
2422 self.common_fields.channel_flags.write(w)?;
2423 encode_tlv_stream!(w, {
2424 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2425 (1, self.common_fields.channel_type, option),
2426 (2, self.require_confirmed_inputs, option),
2432 impl Readable for OpenChannelV2 {
2433 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2434 let chain_hash: ChainHash = Readable::read(r)?;
2435 let temporary_channel_id: ChannelId = Readable::read(r)?;
2436 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2437 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2438 let funding_satoshis: u64 = Readable::read(r)?;
2439 let dust_limit_satoshis: u64 = Readable::read(r)?;
2440 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2441 let htlc_minimum_msat: u64 = Readable::read(r)?;
2442 let to_self_delay: u16 = Readable::read(r)?;
2443 let max_accepted_htlcs: u16 = Readable::read(r)?;
2444 let locktime: u32 = Readable::read(r)?;
2445 let funding_pubkey: PublicKey = Readable::read(r)?;
2446 let revocation_basepoint: PublicKey = Readable::read(r)?;
2447 let payment_basepoint: PublicKey = Readable::read(r)?;
2448 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2449 let htlc_basepoint: PublicKey = Readable::read(r)?;
2450 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2451 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2452 let channel_flags: u8 = Readable::read(r)?;
2454 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2455 let mut channel_type: Option<ChannelTypeFeatures> = None;
2456 let mut require_confirmed_inputs: Option<()> = None;
2457 decode_tlv_stream!(r, {
2458 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2459 (1, channel_type, option),
2460 (2, require_confirmed_inputs, option),
2463 common_fields: CommonOpenChannelFields {
2465 temporary_channel_id,
2467 dust_limit_satoshis,
2468 max_htlc_value_in_flight_msat,
2470 commitment_feerate_sat_per_1000_weight,
2474 revocation_basepoint,
2476 delayed_payment_basepoint,
2478 first_per_commitment_point,
2480 shutdown_scriptpubkey,
2483 funding_feerate_sat_per_1000_weight,
2485 second_per_commitment_point,
2486 require_confirmed_inputs,
2491 #[cfg(not(taproot))]
2492 impl_writeable_msg!(RevokeAndACK, {
2494 per_commitment_secret,
2495 next_per_commitment_point
2499 impl_writeable_msg!(RevokeAndACK, {
2501 per_commitment_secret,
2502 next_per_commitment_point
2504 (4, next_local_nonce, option)
2507 impl_writeable_msg!(Shutdown, {
2512 impl_writeable_msg!(UpdateFailHTLC, {
2518 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2525 impl_writeable_msg!(UpdateFee, {
2530 impl_writeable_msg!(UpdateFulfillHTLC, {
2536 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2537 // serialization format in a way which assumes we know the total serialized length/message end
2539 impl_writeable!(OnionErrorPacket, {
2543 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2544 // serialization format in a way which assumes we know the total serialized length/message end
2546 impl Writeable for OnionPacket {
2547 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2548 self.version.write(w)?;
2549 match self.public_key {
2550 Ok(pubkey) => pubkey.write(w)?,
2551 Err(_) => [0u8;33].write(w)?,
2553 w.write_all(&self.hop_data)?;
2554 self.hmac.write(w)?;
2559 impl Readable for OnionPacket {
2560 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2562 version: Readable::read(r)?,
2564 let mut buf = [0u8;33];
2565 r.read_exact(&mut buf)?;
2566 PublicKey::from_slice(&buf)
2568 hop_data: Readable::read(r)?,
2569 hmac: Readable::read(r)?,
2574 impl_writeable_msg!(UpdateAddHTLC, {
2580 onion_routing_packet,
2582 (0, blinding_point, option),
2583 (65537, skimmed_fee_msat, option)
2586 impl Readable for OnionMessage {
2587 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2588 let blinding_point: PublicKey = Readable::read(r)?;
2589 let len: u16 = Readable::read(r)?;
2590 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2591 let onion_routing_packet: onion_message::packet::Packet =
2592 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2595 onion_routing_packet,
2600 impl Writeable for OnionMessage {
2601 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2602 self.blinding_point.write(w)?;
2603 let onion_packet_len = self.onion_routing_packet.serialized_length();
2604 (onion_packet_len as u16).write(w)?;
2605 self.onion_routing_packet.write(w)?;
2610 impl Writeable for FinalOnionHopData {
2611 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2612 self.payment_secret.0.write(w)?;
2613 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2617 impl Readable for FinalOnionHopData {
2618 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2619 let secret: [u8; 32] = Readable::read(r)?;
2620 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2621 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2625 impl<'a> Writeable for OutboundOnionPayload<'a> {
2626 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2628 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2629 _encode_varint_length_prefixed_tlv!(w, {
2630 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2631 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2632 (6, short_channel_id, required)
2635 Self::TrampolineEntrypoint {
2636 amt_to_forward, outgoing_cltv_value, ref multipath_trampoline_data,
2637 ref trampoline_packet
2639 _encode_varint_length_prefixed_tlv!(w, {
2640 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2641 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2642 (8, multipath_trampoline_data, option),
2643 (20, trampoline_packet, required)
2647 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2648 cltv_expiry_height, ref custom_tlvs,
2650 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2651 // to reject any reserved types in the experimental range if new ones are ever
2653 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2654 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2655 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2656 _encode_varint_length_prefixed_tlv!(w, {
2657 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2658 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2659 (8, payment_data, option),
2660 (16, payment_metadata.map(|m| WithoutLength(m)), option)
2661 }, custom_tlvs.iter());
2663 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2664 _encode_varint_length_prefixed_tlv!(w, {
2665 (10, **encrypted_tlvs, required_vec),
2666 (12, intro_node_blinding_point, option)
2669 Self::BlindedReceive {
2670 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2671 intro_node_blinding_point, keysend_preimage, ref custom_tlvs,
2673 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2674 // to reject any reserved types in the experimental range if new ones are ever
2676 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2677 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2678 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2679 _encode_varint_length_prefixed_tlv!(w, {
2680 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2681 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2682 (10, **encrypted_tlvs, required_vec),
2683 (12, intro_node_blinding_point, option),
2684 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2685 }, custom_tlvs.iter());
2692 impl Writeable for OutboundTrampolinePayload {
2693 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2695 Self::Forward { amt_to_forward, outgoing_cltv_value, outgoing_node_id } => {
2696 _encode_varint_length_prefixed_tlv!(w, {
2697 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2698 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2699 (14, outgoing_node_id, required)
2708 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2709 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2710 let (update_add_blinding_point, node_signer) = args;
2713 let mut cltv_value = None;
2714 let mut short_id: Option<u64> = None;
2715 let mut payment_data: Option<FinalOnionHopData> = None;
2716 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2717 let mut intro_node_blinding_point = None;
2718 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2719 let mut total_msat = None;
2720 let mut keysend_preimage: Option<PaymentPreimage> = None;
2721 let mut custom_tlvs = Vec::new();
2723 let tlv_len = BigSize::read(r)?;
2724 let rd = FixedLengthReader::new(r, tlv_len.0);
2725 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2726 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2727 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2728 (6, short_id, option),
2729 (8, payment_data, option),
2730 (10, encrypted_tlvs_opt, option),
2731 (12, intro_node_blinding_point, option),
2732 (16, payment_metadata, option),
2733 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2734 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2735 (5482373484, keysend_preimage, option)
2736 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2737 if msg_type < 1 << 16 { return Ok(false) }
2738 let mut value = Vec::new();
2739 msg_reader.read_to_end(&mut value)?;
2740 custom_tlvs.push((msg_type, value));
2744 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2745 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2746 return Err(DecodeError::InvalidValue)
2749 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2750 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2751 return Err(DecodeError::InvalidValue)
2753 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2754 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2755 .map_err(|_| DecodeError::InvalidValue)?;
2756 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2757 let mut s = Cursor::new(&enc_tlvs);
2758 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2759 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2760 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2761 short_channel_id, payment_relay, payment_constraints, features
2763 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2764 keysend_preimage.is_some()
2766 return Err(DecodeError::InvalidValue)
2768 Ok(Self::BlindedForward {
2771 payment_constraints,
2773 intro_node_blinding_point,
2776 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2777 payment_secret, payment_constraints, payment_context
2779 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2780 Ok(Self::BlindedReceive {
2781 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2782 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2783 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2785 payment_constraints,
2787 intro_node_blinding_point,
2793 } else if let Some(short_channel_id) = short_id {
2794 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2795 total_msat.is_some()
2796 { return Err(DecodeError::InvalidValue) }
2799 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2800 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2803 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2804 return Err(DecodeError::InvalidValue)
2806 if let Some(data) = &payment_data {
2807 if data.total_msat > MAX_VALUE_MSAT {
2808 return Err(DecodeError::InvalidValue);
2813 payment_metadata: payment_metadata.map(|w| w.0),
2815 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2816 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2823 impl Writeable for Ping {
2824 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2825 self.ponglen.write(w)?;
2826 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2831 impl Readable for Ping {
2832 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2834 ponglen: Readable::read(r)?,
2836 let byteslen = Readable::read(r)?;
2837 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2844 impl Writeable for Pong {
2845 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2846 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2851 impl Readable for Pong {
2852 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2855 let byteslen = Readable::read(r)?;
2856 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2863 impl Writeable for UnsignedChannelAnnouncement {
2864 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2865 self.features.write(w)?;
2866 self.chain_hash.write(w)?;
2867 self.short_channel_id.write(w)?;
2868 self.node_id_1.write(w)?;
2869 self.node_id_2.write(w)?;
2870 self.bitcoin_key_1.write(w)?;
2871 self.bitcoin_key_2.write(w)?;
2872 w.write_all(&self.excess_data[..])?;
2877 impl Readable for UnsignedChannelAnnouncement {
2878 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2880 features: Readable::read(r)?,
2881 chain_hash: Readable::read(r)?,
2882 short_channel_id: Readable::read(r)?,
2883 node_id_1: Readable::read(r)?,
2884 node_id_2: Readable::read(r)?,
2885 bitcoin_key_1: Readable::read(r)?,
2886 bitcoin_key_2: Readable::read(r)?,
2887 excess_data: read_to_end(r)?,
2892 impl_writeable!(ChannelAnnouncement, {
2895 bitcoin_signature_1,
2896 bitcoin_signature_2,
2900 impl Writeable for UnsignedChannelUpdate {
2901 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2902 self.chain_hash.write(w)?;
2903 self.short_channel_id.write(w)?;
2904 self.timestamp.write(w)?;
2905 // The low bit of message_flags used to indicate the presence of `htlc_maximum_msat`, and
2907 (self.message_flags | 1).write(w)?;
2908 self.channel_flags.write(w)?;
2909 self.cltv_expiry_delta.write(w)?;
2910 self.htlc_minimum_msat.write(w)?;
2911 self.fee_base_msat.write(w)?;
2912 self.fee_proportional_millionths.write(w)?;
2913 self.htlc_maximum_msat.write(w)?;
2914 w.write_all(&self.excess_data[..])?;
2919 impl Readable for UnsignedChannelUpdate {
2920 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2922 chain_hash: Readable::read(r)?,
2923 short_channel_id: Readable::read(r)?,
2924 timestamp: Readable::read(r)?,
2925 message_flags: Readable::read(r)?,
2926 channel_flags: Readable::read(r)?,
2927 cltv_expiry_delta: Readable::read(r)?,
2928 htlc_minimum_msat: Readable::read(r)?,
2929 fee_base_msat: Readable::read(r)?,
2930 fee_proportional_millionths: Readable::read(r)?,
2931 htlc_maximum_msat: Readable::read(r)?,
2932 excess_data: read_to_end(r)?,
2934 if res.message_flags & 1 != 1 {
2935 // The `must_be_one` flag should be set (historically it indicated the presence of the
2936 // `htlc_maximum_msat` field, which is now required).
2937 Err(DecodeError::InvalidValue)
2944 impl_writeable!(ChannelUpdate, {
2949 impl Writeable for ErrorMessage {
2950 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2951 self.channel_id.write(w)?;
2952 (self.data.len() as u16).write(w)?;
2953 w.write_all(self.data.as_bytes())?;
2958 impl Readable for ErrorMessage {
2959 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2961 channel_id: Readable::read(r)?,
2963 let sz: usize = <u16 as Readable>::read(r)? as usize;
2964 let mut data = Vec::with_capacity(sz);
2966 r.read_exact(&mut data)?;
2967 match String::from_utf8(data) {
2969 Err(_) => return Err(DecodeError::InvalidValue),
2976 impl Writeable for WarningMessage {
2977 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2978 self.channel_id.write(w)?;
2979 (self.data.len() as u16).write(w)?;
2980 w.write_all(self.data.as_bytes())?;
2985 impl Readable for WarningMessage {
2986 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2988 channel_id: Readable::read(r)?,
2990 let sz: usize = <u16 as Readable>::read(r)? as usize;
2991 let mut data = Vec::with_capacity(sz);
2993 r.read_exact(&mut data)?;
2994 match String::from_utf8(data) {
2996 Err(_) => return Err(DecodeError::InvalidValue),
3003 impl Writeable for UnsignedNodeAnnouncement {
3004 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3005 self.features.write(w)?;
3006 self.timestamp.write(w)?;
3007 self.node_id.write(w)?;
3008 w.write_all(&self.rgb)?;
3009 self.alias.write(w)?;
3011 let mut addr_len = 0;
3012 for addr in self.addresses.iter() {
3013 addr_len += 1 + addr.len();
3015 (addr_len + self.excess_address_data.len() as u16).write(w)?;
3016 for addr in self.addresses.iter() {
3019 w.write_all(&self.excess_address_data[..])?;
3020 w.write_all(&self.excess_data[..])?;
3025 impl Readable for UnsignedNodeAnnouncement {
3026 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3027 let features: NodeFeatures = Readable::read(r)?;
3028 let timestamp: u32 = Readable::read(r)?;
3029 let node_id: NodeId = Readable::read(r)?;
3030 let mut rgb = [0; 3];
3031 r.read_exact(&mut rgb)?;
3032 let alias: NodeAlias = Readable::read(r)?;
3034 let addr_len: u16 = Readable::read(r)?;
3035 let mut addresses: Vec<SocketAddress> = Vec::new();
3036 let mut addr_readpos = 0;
3037 let mut excess = false;
3038 let mut excess_byte = 0;
3040 if addr_len <= addr_readpos { break; }
3041 match Readable::read(r) {
3043 if addr_len < addr_readpos + 1 + addr.len() {
3044 return Err(DecodeError::BadLengthDescriptor);
3046 addr_readpos += (1 + addr.len()) as u16;
3047 addresses.push(addr);
3049 Ok(Err(unknown_descriptor)) => {
3051 excess_byte = unknown_descriptor;
3054 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
3055 Err(e) => return Err(e),
3059 let mut excess_data = vec![];
3060 let excess_address_data = if addr_readpos < addr_len {
3061 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
3062 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
3064 excess_address_data[0] = excess_byte;
3069 excess_data.push(excess_byte);
3073 excess_data.extend(read_to_end(r)?.iter());
3074 Ok(UnsignedNodeAnnouncement {
3081 excess_address_data,
3087 impl_writeable!(NodeAnnouncement, {
3092 impl Readable for QueryShortChannelIds {
3093 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3094 let chain_hash: ChainHash = Readable::read(r)?;
3096 let encoding_len: u16 = Readable::read(r)?;
3097 let encoding_type: u8 = Readable::read(r)?;
3099 // Must be encoding_type=0 uncompressed serialization. We do not
3100 // support encoding_type=1 zlib serialization.
3101 if encoding_type != EncodingType::Uncompressed as u8 {
3102 return Err(DecodeError::UnsupportedCompression);
3105 // We expect the encoding_len to always includes the 1-byte
3106 // encoding_type and that short_channel_ids are 8-bytes each
3107 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3108 return Err(DecodeError::InvalidValue);
3111 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3112 // less the 1-byte encoding_type
3113 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3114 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3115 for _ in 0..short_channel_id_count {
3116 short_channel_ids.push(Readable::read(r)?);
3119 Ok(QueryShortChannelIds {
3126 impl Writeable for QueryShortChannelIds {
3127 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3128 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
3129 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3131 self.chain_hash.write(w)?;
3132 encoding_len.write(w)?;
3134 // We only support type=0 uncompressed serialization
3135 (EncodingType::Uncompressed as u8).write(w)?;
3137 for scid in self.short_channel_ids.iter() {
3145 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3150 impl QueryChannelRange {
3151 /// Calculates the overflow safe ending block height for the query.
3153 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3154 pub fn end_blocknum(&self) -> u32 {
3155 match self.first_blocknum.checked_add(self.number_of_blocks) {
3156 Some(block) => block,
3157 None => u32::max_value(),
3162 impl_writeable_msg!(QueryChannelRange, {
3168 impl Readable for ReplyChannelRange {
3169 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3170 let chain_hash: ChainHash = Readable::read(r)?;
3171 let first_blocknum: u32 = Readable::read(r)?;
3172 let number_of_blocks: u32 = Readable::read(r)?;
3173 let sync_complete: bool = Readable::read(r)?;
3175 let encoding_len: u16 = Readable::read(r)?;
3176 let encoding_type: u8 = Readable::read(r)?;
3178 // Must be encoding_type=0 uncompressed serialization. We do not
3179 // support encoding_type=1 zlib serialization.
3180 if encoding_type != EncodingType::Uncompressed as u8 {
3181 return Err(DecodeError::UnsupportedCompression);
3184 // We expect the encoding_len to always includes the 1-byte
3185 // encoding_type and that short_channel_ids are 8-bytes each
3186 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3187 return Err(DecodeError::InvalidValue);
3190 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3191 // less the 1-byte encoding_type
3192 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3193 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3194 for _ in 0..short_channel_id_count {
3195 short_channel_ids.push(Readable::read(r)?);
3198 Ok(ReplyChannelRange {
3208 impl Writeable for ReplyChannelRange {
3209 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3210 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3211 self.chain_hash.write(w)?;
3212 self.first_blocknum.write(w)?;
3213 self.number_of_blocks.write(w)?;
3214 self.sync_complete.write(w)?;
3216 encoding_len.write(w)?;
3217 (EncodingType::Uncompressed as u8).write(w)?;
3218 for scid in self.short_channel_ids.iter() {
3226 impl_writeable_msg!(GossipTimestampFilter, {
3234 use bitcoin::{Amount, Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3235 use hex::DisplayHex;
3236 use crate::ln::types::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
3237 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3238 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
3239 use crate::ln::msgs::SocketAddress;
3240 use crate::routing::gossip::{NodeAlias, NodeId};
3241 use crate::util::ser::{BigSize, FixedLengthReader, Hostname, LengthReadable, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
3242 use crate::util::test_utils;
3244 use bitcoin::hashes::hex::FromHex;
3245 use bitcoin::address::Address;
3246 use bitcoin::network::Network;
3247 use bitcoin::blockdata::constants::ChainHash;
3248 use bitcoin::blockdata::script::Builder;
3249 use bitcoin::blockdata::opcodes;
3250 use bitcoin::hash_types::Txid;
3251 use bitcoin::locktime::absolute::LockTime;
3252 use bitcoin::transaction::Version;
3254 use bitcoin::secp256k1::{PublicKey,SecretKey};
3255 use bitcoin::secp256k1::{Secp256k1, Message};
3257 use crate::io::{self, Cursor};
3258 use crate::prelude::*;
3259 use core::str::FromStr;
3260 use crate::chain::transaction::OutPoint;
3262 #[cfg(feature = "std")]
3263 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3264 #[cfg(feature = "std")]
3265 use crate::ln::msgs::SocketAddressParseError;
3268 fn encoding_channel_reestablish() {
3270 let secp_ctx = Secp256k1::new();
3271 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3274 let cr = msgs::ChannelReestablish {
3275 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]),
3276 next_local_commitment_number: 3,
3277 next_remote_commitment_number: 4,
3278 your_last_per_commitment_secret: [9;32],
3279 my_current_per_commitment_point: public_key,
3280 next_funding_txid: None,
3283 let encoded_value = cr.encode();
3287 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
3288 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3289 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3290 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
3291 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
3297 fn encoding_channel_reestablish_with_next_funding_txid() {
3299 let secp_ctx = Secp256k1::new();
3300 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3303 let cr = msgs::ChannelReestablish {
3304 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]),
3305 next_local_commitment_number: 3,
3306 next_remote_commitment_number: 4,
3307 your_last_per_commitment_secret: [9;32],
3308 my_current_per_commitment_point: public_key,
3309 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3310 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,
3314 let encoded_value = cr.encode();
3318 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
3319 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3320 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3321 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
3322 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
3323 0, // Type (next_funding_txid)
3325 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
3330 macro_rules! get_keys_from {
3331 ($slice: expr, $secp_ctx: expr) => {
3333 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3334 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3340 macro_rules! get_sig_on {
3341 ($privkey: expr, $ctx: expr, $string: expr) => {
3343 let sighash = Message::from_digest_slice(&$string.into_bytes()[..]).unwrap();
3344 $ctx.sign_ecdsa(&sighash, &$privkey)
3350 fn encoding_announcement_signatures() {
3351 let secp_ctx = Secp256k1::new();
3352 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3353 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3354 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3355 let announcement_signatures = msgs::AnnouncementSignatures {
3356 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]),
3357 short_channel_id: 2316138423780173,
3358 node_signature: sig_1,
3359 bitcoin_signature: sig_2,
3362 let encoded_value = announcement_signatures.encode();
3363 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3366 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3367 let secp_ctx = Secp256k1::new();
3368 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3369 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3370 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3371 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3372 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3373 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3374 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3375 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3376 let mut features = ChannelFeatures::empty();
3377 if unknown_features_bits {
3378 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3380 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3382 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3383 short_channel_id: 2316138423780173,
3384 node_id_1: NodeId::from_pubkey(&pubkey_1),
3385 node_id_2: NodeId::from_pubkey(&pubkey_2),
3386 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3387 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3388 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3390 let channel_announcement = msgs::ChannelAnnouncement {
3391 node_signature_1: sig_1,
3392 node_signature_2: sig_2,
3393 bitcoin_signature_1: sig_3,
3394 bitcoin_signature_2: sig_4,
3395 contents: unsigned_channel_announcement,
3397 let encoded_value = channel_announcement.encode();
3398 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3399 if unknown_features_bits {
3400 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3402 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3404 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3405 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3407 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3409 assert_eq!(encoded_value, target_value);
3413 fn encoding_channel_announcement() {
3414 do_encoding_channel_announcement(true, false);
3415 do_encoding_channel_announcement(false, true);
3416 do_encoding_channel_announcement(false, false);
3417 do_encoding_channel_announcement(true, true);
3420 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) {
3421 let secp_ctx = Secp256k1::new();
3422 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3423 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3424 let features = if unknown_features_bits {
3425 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3427 // Set to some features we may support
3428 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3430 let mut addresses = Vec::new();
3432 addresses.push(SocketAddress::TcpIpV4 {
3433 addr: [255, 254, 253, 252],
3438 addresses.push(SocketAddress::TcpIpV6 {
3439 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3444 addresses.push(msgs::SocketAddress::OnionV2(
3445 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3449 addresses.push(msgs::SocketAddress::OnionV3 {
3450 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],
3457 addresses.push(SocketAddress::Hostname {
3458 hostname: Hostname::try_from(String::from("host")).unwrap(),
3462 let mut addr_len = 0;
3463 for addr in &addresses {
3464 addr_len += addr.len() + 1;
3466 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3468 timestamp: 20190119,
3469 node_id: NodeId::from_pubkey(&pubkey_1),
3471 alias: NodeAlias([16;32]),
3473 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() },
3474 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() },
3476 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3477 let node_announcement = msgs::NodeAnnouncement {
3479 contents: unsigned_node_announcement,
3481 let encoded_value = node_announcement.encode();
3482 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3483 if unknown_features_bits {
3484 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3486 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3488 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3489 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3491 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3494 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3497 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3500 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3503 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3505 if excess_address_data {
3506 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3509 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3511 assert_eq!(encoded_value, target_value);
3515 fn encoding_node_announcement() {
3516 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3517 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3518 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3519 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3520 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3521 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3522 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3523 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3524 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3525 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3528 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3529 let secp_ctx = Secp256k1::new();
3530 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3531 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3532 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3533 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3534 short_channel_id: 2316138423780173,
3535 timestamp: 20190119,
3536 message_flags: 1, // Only must_be_one
3537 channel_flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3538 cltv_expiry_delta: 144,
3539 htlc_minimum_msat: 1000000,
3540 htlc_maximum_msat: 131355275467161,
3541 fee_base_msat: 10000,
3542 fee_proportional_millionths: 20,
3543 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3545 let channel_update = msgs::ChannelUpdate {
3547 contents: unsigned_channel_update
3549 let encoded_value = channel_update.encode();
3550 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3551 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3552 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3553 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3554 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3556 let flag = target_value.last_mut().unwrap();
3560 let flag = target_value.last_mut().unwrap();
3561 *flag = *flag | 1 << 1;
3563 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3564 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3566 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3568 assert_eq!(encoded_value, target_value);
3572 fn encoding_channel_update() {
3573 do_encoding_channel_update(false, false, false);
3574 do_encoding_channel_update(false, false, true);
3575 do_encoding_channel_update(true, false, false);
3576 do_encoding_channel_update(true, false, true);
3577 do_encoding_channel_update(false, true, false);
3578 do_encoding_channel_update(false, true, true);
3579 do_encoding_channel_update(true, true, false);
3580 do_encoding_channel_update(true, true, true);
3583 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3584 let secp_ctx = Secp256k1::new();
3585 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3586 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3587 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3588 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3589 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3590 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3591 let open_channel = msgs::OpenChannel {
3592 common_fields: CommonOpenChannelFields {
3593 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3594 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3595 funding_satoshis: 1311768467284833366,
3596 dust_limit_satoshis: 3608586615801332854,
3597 max_htlc_value_in_flight_msat: 8517154655701053848,
3598 htlc_minimum_msat: 2316138423780173,
3599 commitment_feerate_sat_per_1000_weight: 821716,
3600 to_self_delay: 49340,
3601 max_accepted_htlcs: 49340,
3602 funding_pubkey: pubkey_1,
3603 revocation_basepoint: pubkey_2,
3604 payment_basepoint: pubkey_3,
3605 delayed_payment_basepoint: pubkey_4,
3606 htlc_basepoint: pubkey_5,
3607 first_per_commitment_point: pubkey_6,
3608 channel_flags: if random_bit { 1 << 5 } else { 0 },
3609 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3610 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3612 push_msat: 2536655962884945560,
3613 channel_reserve_satoshis: 8665828695742877976,
3615 let encoded_value = open_channel.encode();
3616 let mut target_value = Vec::new();
3617 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3618 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3620 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3622 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3625 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3628 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3630 assert_eq!(encoded_value, target_value);
3634 fn encoding_open_channel() {
3635 do_encoding_open_channel(false, false, false);
3636 do_encoding_open_channel(false, false, true);
3637 do_encoding_open_channel(false, true, false);
3638 do_encoding_open_channel(false, true, true);
3639 do_encoding_open_channel(true, false, false);
3640 do_encoding_open_channel(true, false, true);
3641 do_encoding_open_channel(true, true, false);
3642 do_encoding_open_channel(true, true, true);
3645 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3646 let secp_ctx = Secp256k1::new();
3647 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3648 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3649 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3650 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3651 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3652 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3653 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3654 let open_channelv2 = msgs::OpenChannelV2 {
3655 common_fields: CommonOpenChannelFields {
3656 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3657 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3658 commitment_feerate_sat_per_1000_weight: 821716,
3659 funding_satoshis: 1311768467284833366,
3660 dust_limit_satoshis: 3608586615801332854,
3661 max_htlc_value_in_flight_msat: 8517154655701053848,
3662 htlc_minimum_msat: 2316138423780173,
3663 to_self_delay: 49340,
3664 max_accepted_htlcs: 49340,
3665 funding_pubkey: pubkey_1,
3666 revocation_basepoint: pubkey_2,
3667 payment_basepoint: pubkey_3,
3668 delayed_payment_basepoint: pubkey_4,
3669 htlc_basepoint: pubkey_5,
3670 first_per_commitment_point: pubkey_6,
3671 channel_flags: if random_bit { 1 << 5 } else { 0 },
3672 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3673 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3675 funding_feerate_sat_per_1000_weight: 821716,
3676 locktime: 305419896,
3677 second_per_commitment_point: pubkey_7,
3678 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3680 let encoded_value = open_channelv2.encode();
3681 let mut target_value = Vec::new();
3682 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3683 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3684 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3685 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3686 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3687 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3688 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3689 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3690 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3691 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3692 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3693 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3694 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3695 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3696 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3697 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3698 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3699 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3702 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3704 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3707 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3710 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3712 if require_confirmed_inputs {
3713 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3715 assert_eq!(encoded_value, target_value);
3719 fn encoding_open_channelv2() {
3720 do_encoding_open_channelv2(false, false, false, false);
3721 do_encoding_open_channelv2(false, false, false, true);
3722 do_encoding_open_channelv2(false, false, true, false);
3723 do_encoding_open_channelv2(false, false, true, true);
3724 do_encoding_open_channelv2(false, true, false, false);
3725 do_encoding_open_channelv2(false, true, false, true);
3726 do_encoding_open_channelv2(false, true, true, false);
3727 do_encoding_open_channelv2(false, true, true, true);
3728 do_encoding_open_channelv2(true, false, false, false);
3729 do_encoding_open_channelv2(true, false, false, true);
3730 do_encoding_open_channelv2(true, false, true, false);
3731 do_encoding_open_channelv2(true, false, true, true);
3732 do_encoding_open_channelv2(true, true, false, false);
3733 do_encoding_open_channelv2(true, true, false, true);
3734 do_encoding_open_channelv2(true, true, true, false);
3735 do_encoding_open_channelv2(true, true, true, true);
3738 fn do_encoding_accept_channel(shutdown: bool) {
3739 let secp_ctx = Secp256k1::new();
3740 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3741 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3742 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3743 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3744 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3745 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3746 let accept_channel = msgs::AcceptChannel {
3747 common_fields: CommonAcceptChannelFields {
3748 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3749 dust_limit_satoshis: 1311768467284833366,
3750 max_htlc_value_in_flight_msat: 2536655962884945560,
3751 htlc_minimum_msat: 2316138423780173,
3752 minimum_depth: 821716,
3753 to_self_delay: 49340,
3754 max_accepted_htlcs: 49340,
3755 funding_pubkey: pubkey_1,
3756 revocation_basepoint: pubkey_2,
3757 payment_basepoint: pubkey_3,
3758 delayed_payment_basepoint: pubkey_4,
3759 htlc_basepoint: pubkey_5,
3760 first_per_commitment_point: pubkey_6,
3761 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3764 channel_reserve_satoshis: 3608586615801332854,
3766 next_local_nonce: None,
3768 let encoded_value = accept_channel.encode();
3769 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3771 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3773 assert_eq!(encoded_value, target_value);
3777 fn encoding_accept_channel() {
3778 do_encoding_accept_channel(false);
3779 do_encoding_accept_channel(true);
3782 fn do_encoding_accept_channelv2(shutdown: bool) {
3783 let secp_ctx = Secp256k1::new();
3784 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3785 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3786 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3787 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3788 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3789 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3790 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3791 let accept_channelv2 = msgs::AcceptChannelV2 {
3792 common_fields: CommonAcceptChannelFields {
3793 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3794 dust_limit_satoshis: 1311768467284833366,
3795 max_htlc_value_in_flight_msat: 2536655962884945560,
3796 htlc_minimum_msat: 2316138423780173,
3797 minimum_depth: 821716,
3798 to_self_delay: 49340,
3799 max_accepted_htlcs: 49340,
3800 funding_pubkey: pubkey_1,
3801 revocation_basepoint: pubkey_2,
3802 payment_basepoint: pubkey_3,
3803 delayed_payment_basepoint: pubkey_4,
3804 htlc_basepoint: pubkey_5,
3805 first_per_commitment_point: pubkey_6,
3806 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3809 funding_satoshis: 1311768467284833366,
3810 second_per_commitment_point: pubkey_7,
3811 require_confirmed_inputs: None,
3813 let encoded_value = accept_channelv2.encode();
3814 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3815 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3816 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3817 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3818 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3819 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3820 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3821 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3822 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3823 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3824 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3825 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3826 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3827 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3828 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3830 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3832 assert_eq!(encoded_value, target_value);
3836 fn encoding_accept_channelv2() {
3837 do_encoding_accept_channelv2(false);
3838 do_encoding_accept_channelv2(true);
3842 fn encoding_funding_created() {
3843 let secp_ctx = Secp256k1::new();
3844 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3845 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3846 let funding_created = msgs::FundingCreated {
3847 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3848 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3849 funding_output_index: 255,
3852 partial_signature_with_nonce: None,
3854 next_local_nonce: None,
3856 let encoded_value = funding_created.encode();
3857 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3858 assert_eq!(encoded_value, target_value);
3862 fn encoding_funding_signed() {
3863 let secp_ctx = Secp256k1::new();
3864 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3865 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3866 let funding_signed = msgs::FundingSigned {
3867 channel_id: ChannelId::from_bytes([2; 32]),
3870 partial_signature_with_nonce: None,
3872 let encoded_value = funding_signed.encode();
3873 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3874 assert_eq!(encoded_value, target_value);
3878 fn encoding_channel_ready() {
3879 let secp_ctx = Secp256k1::new();
3880 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3881 let channel_ready = msgs::ChannelReady {
3882 channel_id: ChannelId::from_bytes([2; 32]),
3883 next_per_commitment_point: pubkey_1,
3884 short_channel_id_alias: None,
3886 let encoded_value = channel_ready.encode();
3887 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3888 assert_eq!(encoded_value, target_value);
3892 fn encoding_splice_init() {
3893 let secp_ctx = Secp256k1::new();
3894 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3895 let splice_init = msgs::SpliceInit {
3896 channel_id: ChannelId::from_bytes([2; 32]),
3897 funding_contribution_satoshis: -123456,
3898 funding_feerate_perkw: 2000,
3900 funding_pubkey: pubkey_1,
3901 require_confirmed_inputs: Some(()),
3903 let encoded_value = splice_init.encode();
3904 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202fffffffffffe1dc0000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f0200");
3908 fn encoding_stfu() {
3909 let stfu = msgs::Stfu {
3910 channel_id: ChannelId::from_bytes([2; 32]),
3913 let encoded_value = stfu.encode();
3914 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3918 fn encoding_splice_ack() {
3919 let secp_ctx = Secp256k1::new();
3920 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3921 let splice_ack = msgs::SpliceAck {
3922 channel_id: ChannelId::from_bytes([2; 32]),
3923 funding_contribution_satoshis: -123456,
3924 funding_pubkey: pubkey_1,
3925 require_confirmed_inputs: Some(()),
3927 let encoded_value = splice_ack.encode();
3928 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202fffffffffffe1dc0031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f0200");
3932 fn encoding_splice_locked() {
3933 let splice_locked = msgs::SpliceLocked {
3934 channel_id: ChannelId::from_bytes([2; 32]),
3935 splice_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3937 let encoded_value = splice_locked.encode();
3938 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2");
3942 fn encoding_tx_add_input() {
3943 let tx_add_input = msgs::TxAddInput {
3944 channel_id: ChannelId::from_bytes([2; 32]),
3945 serial_id: 4886718345,
3946 prevtx: TransactionU16LenLimited::new(Transaction {
3947 version: Version::TWO,
3948 lock_time: LockTime::ZERO,
3950 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3951 script_sig: ScriptBuf::new(),
3952 sequence: Sequence(0xfffffffd),
3953 witness: Witness::from_slice(&vec![
3954 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3955 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3959 value: Amount::from_sat(12704566),
3960 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload().script_pubkey(),
3963 value: Amount::from_sat(245148),
3964 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload().script_pubkey(),
3968 prevtx_out: 305419896,
3969 sequence: 305419896,
3970 shared_input_txid: Some(Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap()),
3972 let encoded_value = tx_add_input.encode();
3973 let target_value = "0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd694400000000123456781234567800206e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2";
3974 assert_eq!(encoded_value.as_hex().to_string(), target_value);
3978 fn encoding_tx_add_output() {
3979 let tx_add_output = msgs::TxAddOutput {
3980 channel_id: ChannelId::from_bytes([2; 32]),
3981 serial_id: 4886718345,
3983 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload().script_pubkey(),
3985 let encoded_value = tx_add_output.encode();
3986 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3987 assert_eq!(encoded_value, target_value);
3991 fn encoding_tx_remove_input() {
3992 let tx_remove_input = msgs::TxRemoveInput {
3993 channel_id: ChannelId::from_bytes([2; 32]),
3994 serial_id: 4886718345,
3996 let encoded_value = tx_remove_input.encode();
3997 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3998 assert_eq!(encoded_value, target_value);
4002 fn encoding_tx_remove_output() {
4003 let tx_remove_output = msgs::TxRemoveOutput {
4004 channel_id: ChannelId::from_bytes([2; 32]),
4005 serial_id: 4886718345,
4007 let encoded_value = tx_remove_output.encode();
4008 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
4009 assert_eq!(encoded_value, target_value);
4013 fn encoding_tx_complete() {
4014 let tx_complete = msgs::TxComplete {
4015 channel_id: ChannelId::from_bytes([2; 32]),
4017 let encoded_value = tx_complete.encode();
4018 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4019 assert_eq!(encoded_value, target_value);
4023 fn encoding_tx_signatures() {
4024 let secp_ctx = Secp256k1::new();
4025 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4026 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4028 let tx_signatures = msgs::TxSignatures {
4029 channel_id: ChannelId::from_bytes([2; 32]),
4030 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
4032 Witness::from_slice(&vec![
4033 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
4034 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
4035 Witness::from_slice(&vec![
4036 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
4037 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
4039 shared_input_signature: Some(sig_1),
4041 let encoded_value = tx_signatures.encode();
4042 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
4043 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
4044 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
4046 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
4047 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
4048 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
4049 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
4050 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
4051 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
4053 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
4054 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
4055 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
4056 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
4057 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
4058 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
4059 target_value.append(&mut <Vec<u8>>::from_hex("0040").unwrap()); // type and len (64)
4060 target_value.append(&mut <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap());
4061 assert_eq!(encoded_value, target_value);
4064 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4065 let tx_init_rbf = msgs::TxInitRbf {
4066 channel_id: ChannelId::from_bytes([2; 32]),
4067 locktime: 305419896,
4068 feerate_sat_per_1000_weight: 20190119,
4069 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4071 let encoded_value = tx_init_rbf.encode();
4072 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
4073 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
4074 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
4075 if let Some((_, target)) = funding_value_with_hex_target {
4076 target_value.push(0x00); // Type
4077 target_value.push(target.len() as u8 / 2); // Length
4078 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4080 assert_eq!(encoded_value, target_value);
4084 fn encoding_tx_init_rbf() {
4085 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
4086 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
4087 do_encoding_tx_init_rbf(None);
4090 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4091 let tx_ack_rbf = msgs::TxAckRbf {
4092 channel_id: ChannelId::from_bytes([2; 32]),
4093 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4095 let encoded_value = tx_ack_rbf.encode();
4096 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4097 if let Some((_, target)) = funding_value_with_hex_target {
4098 target_value.push(0x00); // Type
4099 target_value.push(target.len() as u8 / 2); // Length
4100 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4102 assert_eq!(encoded_value, target_value);
4106 fn encoding_tx_ack_rbf() {
4107 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
4108 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
4109 do_encoding_tx_ack_rbf(None);
4113 fn encoding_tx_abort() {
4114 let tx_abort = msgs::TxAbort {
4115 channel_id: ChannelId::from_bytes([2; 32]),
4116 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
4118 let encoded_value = tx_abort.encode();
4119 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
4120 assert_eq!(encoded_value, target_value);
4123 fn do_encoding_shutdown(script_type: u8) {
4124 let secp_ctx = Secp256k1::new();
4125 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4126 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
4127 let shutdown = msgs::Shutdown {
4128 channel_id: ChannelId::from_bytes([2; 32]),
4130 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
4131 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
4132 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
4133 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
4135 let encoded_value = shutdown.encode();
4136 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4137 if script_type == 1 {
4138 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
4139 } else if script_type == 2 {
4140 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
4141 } else if script_type == 3 {
4142 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
4143 } else if script_type == 4 {
4144 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
4146 assert_eq!(encoded_value, target_value);
4150 fn encoding_shutdown() {
4151 do_encoding_shutdown(1);
4152 do_encoding_shutdown(2);
4153 do_encoding_shutdown(3);
4154 do_encoding_shutdown(4);
4158 fn encoding_closing_signed() {
4159 let secp_ctx = Secp256k1::new();
4160 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4161 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4162 let closing_signed = msgs::ClosingSigned {
4163 channel_id: ChannelId::from_bytes([2; 32]),
4164 fee_satoshis: 2316138423780173,
4168 let encoded_value = closing_signed.encode();
4169 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4170 assert_eq!(encoded_value, target_value);
4171 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4173 let closing_signed_with_range = msgs::ClosingSigned {
4174 channel_id: ChannelId::from_bytes([2; 32]),
4175 fee_satoshis: 2316138423780173,
4177 fee_range: Some(msgs::ClosingSignedFeeRange {
4178 min_fee_satoshis: 0xdeadbeef,
4179 max_fee_satoshis: 0x1badcafe01234567,
4182 let encoded_value_with_range = closing_signed_with_range.encode();
4183 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4184 assert_eq!(encoded_value_with_range, target_value_with_range);
4185 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4186 closing_signed_with_range);
4190 fn encoding_update_add_htlc() {
4191 let secp_ctx = Secp256k1::new();
4192 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4193 let onion_routing_packet = msgs::OnionPacket {
4195 public_key: Ok(pubkey_1),
4196 hop_data: [1; 20*65],
4199 let update_add_htlc = msgs::UpdateAddHTLC {
4200 channel_id: ChannelId::from_bytes([2; 32]),
4201 htlc_id: 2316138423780173,
4202 amount_msat: 3608586615801332854,
4203 payment_hash: PaymentHash([1; 32]),
4204 cltv_expiry: 821716,
4205 onion_routing_packet,
4206 skimmed_fee_msat: None,
4207 blinding_point: None,
4209 let encoded_value = update_add_htlc.encode();
4210 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4211 assert_eq!(encoded_value, target_value);
4215 fn encoding_update_fulfill_htlc() {
4216 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4217 channel_id: ChannelId::from_bytes([2; 32]),
4218 htlc_id: 2316138423780173,
4219 payment_preimage: PaymentPreimage([1; 32]),
4221 let encoded_value = update_fulfill_htlc.encode();
4222 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4223 assert_eq!(encoded_value, target_value);
4227 fn encoding_update_fail_htlc() {
4228 let reason = OnionErrorPacket {
4229 data: [1; 32].to_vec(),
4231 let update_fail_htlc = msgs::UpdateFailHTLC {
4232 channel_id: ChannelId::from_bytes([2; 32]),
4233 htlc_id: 2316138423780173,
4236 let encoded_value = update_fail_htlc.encode();
4237 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4238 assert_eq!(encoded_value, target_value);
4242 fn encoding_update_fail_malformed_htlc() {
4243 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4244 channel_id: ChannelId::from_bytes([2; 32]),
4245 htlc_id: 2316138423780173,
4246 sha256_of_onion: [1; 32],
4249 let encoded_value = update_fail_malformed_htlc.encode();
4250 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4251 assert_eq!(encoded_value, target_value);
4254 fn do_encoding_commitment_signed(htlcs: bool) {
4255 let secp_ctx = Secp256k1::new();
4256 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4257 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4258 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4259 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4260 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4261 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4262 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4263 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4264 let commitment_signed = msgs::CommitmentSigned {
4265 channel_id: ChannelId::from_bytes([2; 32]),
4267 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4268 batch: Some(msgs::CommitmentSignedBatch { batch_size: 3, funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap() }),
4270 partial_signature_with_nonce: None,
4272 let encoded_value = commitment_signed.encode();
4273 let mut target_value = "0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a".to_string();
4275 target_value += "00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd";
4277 target_value += "0000";
4279 target_value += "002200036e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2"; // batch
4280 assert_eq!(encoded_value.as_hex().to_string(), target_value);
4284 fn encoding_commitment_signed() {
4285 do_encoding_commitment_signed(true);
4286 do_encoding_commitment_signed(false);
4290 fn encoding_revoke_and_ack() {
4291 let secp_ctx = Secp256k1::new();
4292 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4293 let raa = msgs::RevokeAndACK {
4294 channel_id: ChannelId::from_bytes([2; 32]),
4295 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],
4296 next_per_commitment_point: pubkey_1,
4298 next_local_nonce: None,
4300 let encoded_value = raa.encode();
4301 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4302 assert_eq!(encoded_value, target_value);
4306 fn encoding_update_fee() {
4307 let update_fee = msgs::UpdateFee {
4308 channel_id: ChannelId::from_bytes([2; 32]),
4309 feerate_per_kw: 20190119,
4311 let encoded_value = update_fee.encode();
4312 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4313 assert_eq!(encoded_value, target_value);
4317 fn encoding_init() {
4318 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4319 assert_eq!(msgs::Init {
4320 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4321 networks: Some(vec![mainnet_hash]),
4322 remote_network_address: None,
4323 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4324 assert_eq!(msgs::Init {
4325 features: InitFeatures::from_le_bytes(vec![0xFF]),
4327 remote_network_address: None,
4328 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4329 assert_eq!(msgs::Init {
4330 features: InitFeatures::from_le_bytes(vec![]),
4331 networks: Some(vec![mainnet_hash]),
4332 remote_network_address: None,
4333 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4334 assert_eq!(msgs::Init {
4335 features: InitFeatures::from_le_bytes(vec![]),
4336 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4337 remote_network_address: None,
4338 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4339 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4340 networks: Some(vec![mainnet_hash]),
4341 remote_network_address: Some(SocketAddress::TcpIpV4 {
4342 addr: [127, 0, 0, 1],
4346 let encoded_value = init_msg.encode();
4347 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4348 assert_eq!(encoded_value, target_value);
4349 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4353 fn encoding_error() {
4354 let error = msgs::ErrorMessage {
4355 channel_id: ChannelId::from_bytes([2; 32]),
4356 data: String::from("rust-lightning"),
4358 let encoded_value = error.encode();
4359 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4360 assert_eq!(encoded_value, target_value);
4364 fn encoding_warning() {
4365 let error = msgs::WarningMessage {
4366 channel_id: ChannelId::from_bytes([2; 32]),
4367 data: String::from("rust-lightning"),
4369 let encoded_value = error.encode();
4370 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4371 assert_eq!(encoded_value, target_value);
4375 fn encoding_ping() {
4376 let ping = msgs::Ping {
4380 let encoded_value = ping.encode();
4381 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4382 assert_eq!(encoded_value, target_value);
4386 fn encoding_pong() {
4387 let pong = msgs::Pong {
4390 let encoded_value = pong.encode();
4391 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4392 assert_eq!(encoded_value, target_value);
4396 fn encoding_nonfinal_onion_hop_data() {
4397 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4398 short_channel_id: 0xdeadbeef1bad1dea,
4399 amt_to_forward: 0x0badf00d01020304,
4400 outgoing_cltv_value: 0xffffffff,
4402 let encoded_value = outbound_msg.encode();
4403 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4404 assert_eq!(encoded_value, target_value);
4406 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4407 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4408 if let msgs::InboundOnionPayload::Forward {
4409 short_channel_id, amt_to_forward, outgoing_cltv_value
4411 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4412 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4413 assert_eq!(outgoing_cltv_value, 0xffffffff);
4414 } else { panic!(); }
4418 fn encoding_final_onion_hop_data() {
4419 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4421 payment_metadata: None,
4422 keysend_preimage: None,
4423 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4424 cltv_expiry_height: 0xffffffff,
4425 custom_tlvs: &vec![],
4427 let encoded_value = outbound_msg.encode();
4428 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4429 assert_eq!(encoded_value, target_value);
4431 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4432 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4433 if let msgs::InboundOnionPayload::Receive {
4434 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4436 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4437 assert_eq!(cltv_expiry_height, 0xffffffff);
4438 } else { panic!(); }
4442 fn encoding_final_onion_hop_data_with_secret() {
4443 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4444 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4445 payment_data: Some(FinalOnionHopData {
4446 payment_secret: expected_payment_secret,
4447 total_msat: 0x1badca1f
4449 payment_metadata: None,
4450 keysend_preimage: None,
4451 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4452 cltv_expiry_height: 0xffffffff,
4453 custom_tlvs: &vec![],
4455 let encoded_value = outbound_msg.encode();
4456 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4457 assert_eq!(encoded_value, target_value);
4459 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4460 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4461 if let msgs::InboundOnionPayload::Receive {
4462 payment_data: Some(FinalOnionHopData {
4464 total_msat: 0x1badca1f
4466 sender_intended_htlc_amt_msat, cltv_expiry_height,
4467 payment_metadata: None,
4468 keysend_preimage: None,
4471 assert_eq!(payment_secret, expected_payment_secret);
4472 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4473 assert_eq!(cltv_expiry_height, 0xffffffff);
4474 assert_eq!(custom_tlvs, vec![]);
4475 } else { panic!(); }
4479 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4480 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4482 let bad_type_range_tlvs = vec![
4483 ((1 << 16) - 4, vec![42]),
4484 ((1 << 16) - 2, vec![42; 32]),
4486 let mut msg = msgs::OutboundOnionPayload::Receive {
4488 payment_metadata: None,
4489 keysend_preimage: None,
4490 custom_tlvs: &bad_type_range_tlvs,
4491 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4492 cltv_expiry_height: 0xffffffff,
4494 let encoded_value = msg.encode();
4495 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4496 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4497 let good_type_range_tlvs = vec![
4498 ((1 << 16) - 3, vec![42]),
4499 ((1 << 16) - 1, vec![42; 32]),
4501 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4502 *custom_tlvs = &good_type_range_tlvs;
4504 let encoded_value = msg.encode();
4505 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4507 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4513 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4514 let expected_custom_tlvs = vec![
4515 (5482373483, vec![0x12, 0x34]),
4516 (5482373487, vec![0x42u8; 8]),
4518 let msg = msgs::OutboundOnionPayload::Receive {
4520 payment_metadata: None,
4521 keysend_preimage: None,
4522 custom_tlvs: &expected_custom_tlvs,
4523 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4524 cltv_expiry_height: 0xffffffff,
4526 let encoded_value = msg.encode();
4527 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4528 assert_eq!(encoded_value, target_value);
4529 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4530 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4531 if let msgs::InboundOnionPayload::Receive {
4533 payment_metadata: None,
4534 keysend_preimage: None,
4536 sender_intended_htlc_amt_msat,
4537 cltv_expiry_height: outgoing_cltv_value,
4540 assert_eq!(custom_tlvs, expected_custom_tlvs);
4541 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4542 assert_eq!(outgoing_cltv_value, 0xffffffff);
4543 } else { panic!(); }
4547 fn encoding_final_onion_hop_data_with_trampoline_packet() {
4548 let secp_ctx = Secp256k1::new();
4549 let (_private_key, public_key) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4551 let compressed_public_key = public_key.serialize();
4552 assert_eq!(compressed_public_key.len(), 33);
4554 let trampoline_packet = TrampolineOnionPacket {
4557 hop_data: vec![1; 650], // this should be the standard encoded length
4560 let encoded_trampoline_packet = trampoline_packet.encode();
4561 assert_eq!(encoded_trampoline_packet.len(), 716);
4563 { // verify that a codec round trip works
4564 let mut reader = Cursor::new(&encoded_trampoline_packet);
4565 let mut trampoline_packet_reader = FixedLengthReader::new(&mut reader, encoded_trampoline_packet.len() as u64);
4566 let decoded_trampoline_packet: TrampolineOnionPacket = <TrampolineOnionPacket as LengthReadable>::read(&mut trampoline_packet_reader).unwrap();
4567 assert_eq!(decoded_trampoline_packet.encode(), encoded_trampoline_packet);
4570 let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
4571 multipath_trampoline_data: None,
4572 amt_to_forward: 0x0badf00d01020304,
4573 outgoing_cltv_value: 0xffffffff,
4576 let encoded_payload = msg.encode();
4578 let trampoline_type_bytes = &encoded_payload[19..=19];
4579 let mut trampoline_type_cursor = Cursor::new(trampoline_type_bytes);
4580 let trampoline_type_big_size: BigSize = Readable::read(&mut trampoline_type_cursor).unwrap();
4581 assert_eq!(trampoline_type_big_size.0, 20);
4583 let trampoline_length_bytes = &encoded_payload[20..=22];
4584 let mut trampoline_length_cursor = Cursor::new(trampoline_length_bytes);
4585 let trampoline_length_big_size: BigSize = Readable::read(&mut trampoline_length_cursor).unwrap();
4586 assert_eq!(trampoline_length_big_size.0, encoded_trampoline_packet.len() as u64);
4590 fn encoding_final_onion_hop_data_with_eclair_trampoline_packet() {
4591 let public_key = PublicKey::from_slice(&<Vec<u8>>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()).unwrap();
4592 let hop_data = <Vec<u8>>::from_hex("cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4c").unwrap();
4593 let hmac_vector = <Vec<u8>>::from_hex("bb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4594 let mut hmac = [0; 32];
4595 hmac.copy_from_slice(&hmac_vector);
4597 let compressed_public_key = public_key.serialize();
4598 assert_eq!(compressed_public_key.len(), 33);
4600 let trampoline_packet = TrampolineOnionPacket {
4606 let encoded_trampoline_packet = trampoline_packet.encode();
4607 let expected_eclair_trampoline_packet = <Vec<u8>>::from_hex("0002eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4cbb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4608 assert_eq!(encoded_trampoline_packet, expected_eclair_trampoline_packet);
4612 fn query_channel_range_end_blocknum() {
4613 let tests: Vec<(u32, u32, u32)> = vec![
4614 (10000, 1500, 11500),
4615 (0, 0xffffffff, 0xffffffff),
4616 (1, 0xffffffff, 0xffffffff),
4619 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4620 let sut = msgs::QueryChannelRange {
4621 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4625 assert_eq!(sut.end_blocknum(), expected);
4630 fn encoding_query_channel_range() {
4631 let mut query_channel_range = msgs::QueryChannelRange {
4632 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4633 first_blocknum: 100000,
4634 number_of_blocks: 1500,
4636 let encoded_value = query_channel_range.encode();
4637 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4638 assert_eq!(encoded_value, target_value);
4640 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4641 assert_eq!(query_channel_range.first_blocknum, 100000);
4642 assert_eq!(query_channel_range.number_of_blocks, 1500);
4646 fn encoding_reply_channel_range() {
4647 do_encoding_reply_channel_range(0);
4648 do_encoding_reply_channel_range(1);
4651 fn do_encoding_reply_channel_range(encoding_type: u8) {
4652 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4653 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4654 let mut reply_channel_range = msgs::ReplyChannelRange {
4655 chain_hash: expected_chain_hash,
4656 first_blocknum: 756230,
4657 number_of_blocks: 1500,
4658 sync_complete: true,
4659 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4662 if encoding_type == 0 {
4663 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4664 let encoded_value = reply_channel_range.encode();
4665 assert_eq!(encoded_value, target_value);
4667 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4668 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4669 assert_eq!(reply_channel_range.first_blocknum, 756230);
4670 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4671 assert_eq!(reply_channel_range.sync_complete, true);
4672 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4673 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4674 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4676 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4677 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4678 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4683 fn encoding_query_short_channel_ids() {
4684 do_encoding_query_short_channel_ids(0);
4685 do_encoding_query_short_channel_ids(1);
4688 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4689 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4690 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4691 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4692 chain_hash: expected_chain_hash,
4693 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4696 if encoding_type == 0 {
4697 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4698 let encoded_value = query_short_channel_ids.encode();
4699 assert_eq!(encoded_value, target_value);
4701 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4702 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4703 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4704 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4705 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4707 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4708 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4709 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4714 fn encoding_reply_short_channel_ids_end() {
4715 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4716 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4717 chain_hash: expected_chain_hash,
4718 full_information: true,
4720 let encoded_value = reply_short_channel_ids_end.encode();
4721 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4722 assert_eq!(encoded_value, target_value);
4724 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4725 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4726 assert_eq!(reply_short_channel_ids_end.full_information, true);
4730 fn encoding_gossip_timestamp_filter(){
4731 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4732 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4733 chain_hash: expected_chain_hash,
4734 first_timestamp: 1590000000,
4735 timestamp_range: 0xffff_ffff,
4737 let encoded_value = gossip_timestamp_filter.encode();
4738 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4739 assert_eq!(encoded_value, target_value);
4741 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4742 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4743 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4744 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4748 fn decode_onion_hop_data_len_as_bigsize() {
4749 // Tests that we can decode an onion payload that is >253 bytes.
4750 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4751 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4754 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4755 // payload length to be encoded over multiple bytes rather than a single u8.
4756 let big_payload = encode_big_payload().unwrap();
4757 let mut rd = Cursor::new(&big_payload[..]);
4759 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4760 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4761 ::read(&mut rd, (None, &&node_signer)).unwrap();
4763 // see above test, needs to be a separate method for use of the serialization macros.
4764 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4765 use crate::util::ser::HighZeroBytesDroppedBigSize;
4766 let payload = msgs::OutboundOnionPayload::Forward {
4767 short_channel_id: 0xdeadbeef1bad1dea,
4768 amt_to_forward: 1000,
4769 outgoing_cltv_value: 0xffffffff,
4771 let mut encoded_payload = Vec::new();
4772 let test_bytes = vec![42u8; 1000];
4773 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4774 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4775 (1, test_bytes, required_vec),
4776 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4777 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4778 (6, short_channel_id, required)
4785 #[cfg(feature = "std")]
4786 fn test_socket_address_from_str() {
4787 let tcpip_v4 = SocketAddress::TcpIpV4 {
4788 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4791 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4792 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4794 let tcpip_v6 = SocketAddress::TcpIpV6 {
4795 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4798 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4799 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4801 let hostname = SocketAddress::Hostname {
4802 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4805 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4806 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4808 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4809 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4810 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4812 let onion_v3 = SocketAddress::OnionV3 {
4813 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4814 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4819 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4820 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4822 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4823 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4824 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4825 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4826 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4827 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4828 assert!("localhost".parse::<SocketAddress>().is_err());
4829 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4830 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4831 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4832 assert!("invalid-address".parse::<SocketAddress>().is_err());
4833 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4837 #[cfg(feature = "std")]
4838 fn test_socket_address_to_socket_addrs() {
4839 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4840 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4841 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4842 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4843 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4844 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4845 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4846 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4847 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4851 port: 1234 }.to_socket_addrs().is_err());