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.
414 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
415 #[derive(Clone, Debug, PartialEq, Eq)]
417 /// The channel ID where quiescence is intended
418 pub channel_id: ChannelId,
419 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
423 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
424 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
425 #[derive(Clone, Debug, PartialEq, Eq)]
427 /// The channel ID where splicing is intended
428 pub channel_id: ChannelId,
429 /// The genesis hash of the blockchain where the channel is intended to be spliced
430 pub chain_hash: ChainHash,
431 /// The intended change in channel capacity: the amount to be added (positive value)
432 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
433 pub relative_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,
442 /// A splice_ack message to be received by or sent to the splice initiator.
444 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
445 #[derive(Clone, Debug, PartialEq, Eq)]
446 pub struct SpliceAck {
447 /// The channel ID where splicing is intended
448 pub channel_id: ChannelId,
449 /// The genesis hash of the blockchain where the channel is intended to be spliced
450 pub chain_hash: ChainHash,
451 /// The intended change in channel capacity: the amount to be added (positive value)
452 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
453 pub relative_satoshis: i64,
454 /// The key of the sender (splice acceptor) controlling the new funding transaction
455 pub funding_pubkey: PublicKey,
458 /// A splice_locked message to be sent to or received from a peer.
460 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
461 #[derive(Clone, Debug, PartialEq, Eq)]
462 pub struct SpliceLocked {
464 pub channel_id: ChannelId,
467 /// A tx_add_input message for adding an input during interactive transaction construction
469 // TODO(dual_funding): Add spec link for `tx_add_input`.
470 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
471 pub struct TxAddInput {
473 pub channel_id: ChannelId,
474 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
476 pub serial_id: SerialId,
477 /// Serialized transaction that contains the output this input spends to verify that it is non
479 pub prevtx: TransactionU16LenLimited,
480 /// The index of the output being spent
482 /// The sequence number of this input
486 /// A tx_add_output message for adding an output during interactive transaction construction.
488 // TODO(dual_funding): Add spec link for `tx_add_output`.
489 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
490 pub struct TxAddOutput {
492 pub channel_id: ChannelId,
493 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
495 pub serial_id: SerialId,
496 /// The satoshi value of the output
498 /// The scriptPubKey for the output
499 pub script: ScriptBuf,
502 /// A tx_remove_input message for removing an input during interactive transaction construction.
504 // TODO(dual_funding): Add spec link for `tx_remove_input`.
505 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
506 pub struct TxRemoveInput {
508 pub channel_id: ChannelId,
509 /// The serial ID of the input to be removed
510 pub serial_id: SerialId,
513 /// A tx_remove_output message for removing an output during interactive transaction construction.
515 // TODO(dual_funding): Add spec link for `tx_remove_output`.
516 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
517 pub struct TxRemoveOutput {
519 pub channel_id: ChannelId,
520 /// The serial ID of the output to be removed
521 pub serial_id: SerialId,
524 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
525 /// interactive transaction construction.
527 // TODO(dual_funding): Add spec link for `tx_complete`.
528 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
529 pub struct TxComplete {
531 pub channel_id: ChannelId,
534 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
535 /// interactive transaction construction.
537 // TODO(dual_funding): Add spec link for `tx_signatures`.
538 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
539 pub struct TxSignatures {
541 pub channel_id: ChannelId,
544 /// The list of witnesses
545 pub witnesses: Vec<Witness>,
546 /// Optional signature for the shared input -- the previous funding outpoint -- signed by both peers
547 pub funding_outpoint_sig: Option<Signature>,
550 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
553 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
554 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
555 pub struct TxInitRbf {
557 pub channel_id: ChannelId,
558 /// The locktime of the transaction
560 /// The feerate of the transaction
561 pub feerate_sat_per_1000_weight: u32,
562 /// The number of satoshis the sender will contribute to or, if negative, remove from
563 /// (e.g. splice-out) the funding output of the transaction
564 pub funding_output_contribution: Option<i64>,
567 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
570 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
571 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
572 pub struct TxAckRbf {
574 pub channel_id: ChannelId,
575 /// The number of satoshis the sender will contribute to or, if negative, remove from
576 /// (e.g. splice-out) the funding output of the transaction
577 pub funding_output_contribution: Option<i64>,
580 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
582 // TODO(dual_funding): Add spec link for `tx_abort`.
583 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
586 pub channel_id: ChannelId,
591 /// A [`shutdown`] message to be sent to or received from a peer.
593 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
594 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
595 pub struct Shutdown {
597 pub channel_id: ChannelId,
598 /// The destination of this peer's funds on closing.
600 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
601 pub scriptpubkey: ScriptBuf,
604 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
606 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
608 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
609 pub struct ClosingSignedFeeRange {
610 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
612 pub min_fee_satoshis: u64,
613 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
615 pub max_fee_satoshis: u64,
618 /// A [`closing_signed`] message to be sent to or received from a peer.
620 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
621 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
622 pub struct ClosingSigned {
624 pub channel_id: ChannelId,
625 /// The proposed total fee for the closing transaction
626 pub fee_satoshis: u64,
627 /// A signature on the closing transaction
628 pub signature: Signature,
629 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
631 pub fee_range: Option<ClosingSignedFeeRange>,
634 /// An [`update_add_htlc`] message to be sent to or received from a peer.
636 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
637 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
638 pub struct UpdateAddHTLC {
640 pub channel_id: ChannelId,
643 /// The HTLC value in milli-satoshi
644 pub amount_msat: u64,
645 /// The payment hash, the pre-image of which controls HTLC redemption
646 pub payment_hash: PaymentHash,
647 /// The expiry height of the HTLC
648 pub cltv_expiry: u32,
649 /// The extra fee skimmed by the sender of this message. See
650 /// [`ChannelConfig::accept_underpaying_htlcs`].
652 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
653 pub skimmed_fee_msat: Option<u64>,
654 /// The onion routing packet with encrypted data for the next hop.
655 pub onion_routing_packet: OnionPacket,
656 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
657 /// routing packet and the recipient-provided encrypted payload within.
658 pub blinding_point: Option<PublicKey>,
661 /// An onion message to be sent to or received from a peer.
663 // TODO: update with link to OM when they are merged into the BOLTs
664 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
665 pub struct OnionMessage {
666 /// Used in decrypting the onion packet's payload.
667 pub blinding_point: PublicKey,
668 /// The full onion packet including hop data, pubkey, and hmac
669 pub onion_routing_packet: onion_message::packet::Packet,
672 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
674 /// [`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
675 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
676 pub struct UpdateFulfillHTLC {
678 pub channel_id: ChannelId,
681 /// The pre-image of the payment hash, allowing HTLC redemption
682 pub payment_preimage: PaymentPreimage,
685 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
687 /// [`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
688 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
689 pub struct UpdateFailHTLC {
691 pub channel_id: ChannelId,
694 pub(crate) reason: OnionErrorPacket,
697 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
699 /// [`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
700 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
701 pub struct UpdateFailMalformedHTLC {
703 pub channel_id: ChannelId,
706 pub(crate) sha256_of_onion: [u8; 32],
708 pub failure_code: u16,
711 /// A [`commitment_signed`] message to be sent to or received from a peer.
713 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
714 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
715 pub struct CommitmentSigned {
717 pub channel_id: ChannelId,
718 /// A signature on the commitment transaction
719 pub signature: Signature,
720 /// Signatures on the HTLC transactions
721 pub htlc_signatures: Vec<Signature>,
723 /// The partial Taproot signature on the commitment transaction
724 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
727 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
729 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
730 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
731 pub struct RevokeAndACK {
733 pub channel_id: ChannelId,
734 /// The secret corresponding to the per-commitment point
735 pub per_commitment_secret: [u8; 32],
736 /// The next sender-broadcast commitment transaction's per-commitment point
737 pub next_per_commitment_point: PublicKey,
739 /// Musig nonce the recipient should use in their next commitment signature message
740 pub next_local_nonce: Option<musig2::types::PublicNonce>
743 /// An [`update_fee`] message to be sent to or received from a peer
745 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
746 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
747 pub struct UpdateFee {
749 pub channel_id: ChannelId,
750 /// Fee rate per 1000-weight of the transaction
751 pub feerate_per_kw: u32,
754 /// A [`channel_reestablish`] message to be sent to or received from a peer.
756 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
757 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
758 pub struct ChannelReestablish {
760 pub channel_id: ChannelId,
761 /// The next commitment number for the sender
762 pub next_local_commitment_number: u64,
763 /// The next commitment number for the recipient
764 pub next_remote_commitment_number: u64,
765 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
766 /// belonging to the recipient
767 pub your_last_per_commitment_secret: [u8; 32],
768 /// The sender's per-commitment point for their current commitment transaction
769 pub my_current_per_commitment_point: PublicKey,
770 /// The next funding transaction ID
771 pub next_funding_txid: Option<Txid>,
774 /// An [`announcement_signatures`] message to be sent to or received from a peer.
776 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
777 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
778 pub struct AnnouncementSignatures {
780 pub channel_id: ChannelId,
781 /// The short channel ID
782 pub short_channel_id: u64,
783 /// A signature by the node key
784 pub node_signature: Signature,
785 /// A signature by the funding key
786 pub bitcoin_signature: Signature,
789 /// An address which can be used to connect to a remote peer.
790 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
791 pub enum SocketAddress {
792 /// An IPv4 address and port on which the peer is listening.
794 /// The 4-byte IPv4 address
796 /// The port on which the node is listening
799 /// An IPv6 address and port on which the peer is listening.
801 /// The 16-byte IPv6 address
803 /// The port on which the node is listening
806 /// An old-style Tor onion address/port on which the peer is listening.
808 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
809 /// addresses. Thus, the details are not parsed here.
811 /// A new-style Tor onion address/port on which the peer is listening.
813 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
814 /// wrap as base32 and append ".onion".
816 /// The ed25519 long-term public key of the peer
817 ed25519_pubkey: [u8; 32],
818 /// The checksum of the pubkey and version, as included in the onion address
820 /// The version byte, as defined by the Tor Onion v3 spec.
822 /// The port on which the node is listening
825 /// A hostname/port on which the peer is listening.
827 /// The hostname on which the node is listening.
829 /// The port on which the node is listening.
834 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
836 pub(crate) fn get_id(&self) -> u8 {
838 &SocketAddress::TcpIpV4 {..} => { 1 },
839 &SocketAddress::TcpIpV6 {..} => { 2 },
840 &SocketAddress::OnionV2(_) => { 3 },
841 &SocketAddress::OnionV3 {..} => { 4 },
842 &SocketAddress::Hostname {..} => { 5 },
846 /// Strict byte-length of address descriptor, 1-byte type not recorded
847 fn len(&self) -> u16 {
849 &SocketAddress::TcpIpV4 { .. } => { 6 },
850 &SocketAddress::TcpIpV6 { .. } => { 18 },
851 &SocketAddress::OnionV2(_) => { 12 },
852 &SocketAddress::OnionV3 { .. } => { 37 },
853 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
854 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
858 /// The maximum length of any address descriptor, not including the 1-byte type.
859 /// This maximum length is reached by a hostname address descriptor:
860 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
861 pub(crate) const MAX_LEN: u16 = 258;
863 pub(crate) fn is_tor(&self) -> bool {
865 &SocketAddress::TcpIpV4 {..} => false,
866 &SocketAddress::TcpIpV6 {..} => false,
867 &SocketAddress::OnionV2(_) => true,
868 &SocketAddress::OnionV3 {..} => true,
869 &SocketAddress::Hostname {..} => false,
874 impl Writeable for SocketAddress {
875 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
877 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
882 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
887 &SocketAddress::OnionV2(bytes) => {
889 bytes.write(writer)?;
891 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
893 ed25519_pubkey.write(writer)?;
894 checksum.write(writer)?;
895 version.write(writer)?;
898 &SocketAddress::Hostname { ref hostname, ref port } => {
900 hostname.write(writer)?;
908 impl Readable for Result<SocketAddress, u8> {
909 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
910 let byte = <u8 as Readable>::read(reader)?;
913 Ok(Ok(SocketAddress::TcpIpV4 {
914 addr: Readable::read(reader)?,
915 port: Readable::read(reader)?,
919 Ok(Ok(SocketAddress::TcpIpV6 {
920 addr: Readable::read(reader)?,
921 port: Readable::read(reader)?,
924 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
926 Ok(Ok(SocketAddress::OnionV3 {
927 ed25519_pubkey: Readable::read(reader)?,
928 checksum: Readable::read(reader)?,
929 version: Readable::read(reader)?,
930 port: Readable::read(reader)?,
934 Ok(Ok(SocketAddress::Hostname {
935 hostname: Readable::read(reader)?,
936 port: Readable::read(reader)?,
939 _ => return Ok(Err(byte)),
944 impl Readable for SocketAddress {
945 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
946 match Readable::read(reader) {
947 Ok(Ok(res)) => Ok(res),
948 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
954 /// [`SocketAddress`] error variants
955 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
956 pub enum SocketAddressParseError {
957 /// Socket address (IPv4/IPv6) parsing error
959 /// Invalid input format
963 /// Invalid onion v3 address
967 impl fmt::Display for SocketAddressParseError {
968 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
970 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
971 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
972 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
973 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
974 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
979 #[cfg(feature = "std")]
980 impl From<std::net::SocketAddrV4> for SocketAddress {
981 fn from(addr: std::net::SocketAddrV4) -> Self {
982 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
986 #[cfg(feature = "std")]
987 impl From<std::net::SocketAddrV6> for SocketAddress {
988 fn from(addr: std::net::SocketAddrV6) -> Self {
989 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
993 #[cfg(feature = "std")]
994 impl From<std::net::SocketAddr> for SocketAddress {
995 fn from(addr: std::net::SocketAddr) -> Self {
997 std::net::SocketAddr::V4(addr) => addr.into(),
998 std::net::SocketAddr::V6(addr) => addr.into(),
1003 #[cfg(feature = "std")]
1004 impl std::net::ToSocketAddrs for SocketAddress {
1005 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1007 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1009 SocketAddress::TcpIpV4 { addr, port } => {
1010 let ip_addr = std::net::Ipv4Addr::from(*addr);
1011 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1012 Ok(vec![socket_addr].into_iter())
1014 SocketAddress::TcpIpV6 { addr, port } => {
1015 let ip_addr = std::net::Ipv6Addr::from(*addr);
1016 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1017 Ok(vec![socket_addr].into_iter())
1019 SocketAddress::Hostname { ref hostname, port } => {
1020 (hostname.as_str(), *port).to_socket_addrs()
1022 SocketAddress::OnionV2(..) => {
1023 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1024 addresses is currently unsupported."))
1026 SocketAddress::OnionV3 { .. } => {
1027 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1028 addresses is currently unsupported."))
1034 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1036 /// The host part must end with ".onion".
1037 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1038 if host.ends_with(".onion") {
1039 let domain = &host[..host.len() - ".onion".len()];
1040 if domain.len() != 56 {
1041 return Err(SocketAddressParseError::InvalidOnionV3);
1043 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1044 if onion.len() != 35 {
1045 return Err(SocketAddressParseError::InvalidOnionV3);
1047 let version = onion[0];
1048 let first_checksum_flag = onion[1];
1049 let second_checksum_flag = onion[2];
1050 let mut ed25519_pubkey = [0; 32];
1051 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1052 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1053 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1056 return Err(SocketAddressParseError::InvalidInput);
1060 impl Display for SocketAddress {
1061 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1063 SocketAddress::TcpIpV4{addr, port} => write!(
1064 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1065 SocketAddress::TcpIpV6{addr, port} => write!(
1067 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1068 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
1070 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1071 SocketAddress::OnionV3 {
1077 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1078 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1079 addr.extend_from_slice(ed25519_pubkey);
1080 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1081 write!(f, "{}.onion:{}", onion, port)?
1083 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1089 #[cfg(feature = "std")]
1090 impl FromStr for SocketAddress {
1091 type Err = SocketAddressParseError;
1093 fn from_str(s: &str) -> Result<Self, Self::Err> {
1094 match std::net::SocketAddr::from_str(s) {
1095 Ok(addr) => Ok(addr.into()),
1097 let trimmed_input = match s.rfind(":") {
1099 None => return Err(SocketAddressParseError::InvalidInput),
1101 let host = &s[..trimmed_input];
1102 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1103 if host.ends_with(".onion") {
1104 return parse_onion_address(host, port);
1106 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1107 return Ok(SocketAddress::Hostname { hostname, port });
1109 return Err(SocketAddressParseError::SocketAddrParse)
1115 /// Represents the set of gossip messages that require a signature from a node's identity key.
1116 pub enum UnsignedGossipMessage<'a> {
1117 /// An unsigned channel announcement.
1118 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1119 /// An unsigned channel update.
1120 ChannelUpdate(&'a UnsignedChannelUpdate),
1121 /// An unsigned node announcement.
1122 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1125 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1126 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1128 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1129 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1130 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1135 /// The unsigned part of a [`node_announcement`] message.
1137 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1138 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1139 pub struct UnsignedNodeAnnouncement {
1140 /// The advertised features
1141 pub features: NodeFeatures,
1142 /// A strictly monotonic announcement counter, with gaps allowed
1144 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1146 pub node_id: NodeId,
1147 /// An RGB color for UI purposes
1149 /// An alias, for UI purposes.
1151 /// This should be sanitized before use. There is no guarantee of uniqueness.
1152 pub alias: NodeAlias,
1153 /// List of addresses on which this node is reachable
1154 pub addresses: Vec<SocketAddress>,
1155 /// Excess address data which was signed as a part of the message which we do not (yet) understand how
1158 /// This is stored to ensure forward-compatibility as new address types are added to the lightning gossip protocol.
1159 pub excess_address_data: Vec<u8>,
1160 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1163 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1164 pub excess_data: Vec<u8>,
1166 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1167 /// A [`node_announcement`] message to be sent to or received from a peer.
1169 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1170 pub struct NodeAnnouncement {
1171 /// The signature by the node key
1172 pub signature: Signature,
1173 /// The actual content of the announcement
1174 pub contents: UnsignedNodeAnnouncement,
1177 /// The unsigned part of a [`channel_announcement`] message.
1179 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1180 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1181 pub struct UnsignedChannelAnnouncement {
1182 /// The advertised channel features
1183 pub features: ChannelFeatures,
1184 /// The genesis hash of the blockchain where the channel is to be opened
1185 pub chain_hash: ChainHash,
1186 /// The short channel ID
1187 pub short_channel_id: u64,
1188 /// One of the two `node_id`s which are endpoints of this channel
1189 pub node_id_1: NodeId,
1190 /// The other of the two `node_id`s which are endpoints of this channel
1191 pub node_id_2: NodeId,
1192 /// The funding key for the first node
1193 pub bitcoin_key_1: NodeId,
1194 /// The funding key for the second node
1195 pub bitcoin_key_2: NodeId,
1196 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1199 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1200 pub excess_data: Vec<u8>,
1202 /// A [`channel_announcement`] message to be sent to or received from a peer.
1204 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1205 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1206 pub struct ChannelAnnouncement {
1207 /// Authentication of the announcement by the first public node
1208 pub node_signature_1: Signature,
1209 /// Authentication of the announcement by the second public node
1210 pub node_signature_2: Signature,
1211 /// Proof of funding UTXO ownership by the first public node
1212 pub bitcoin_signature_1: Signature,
1213 /// Proof of funding UTXO ownership by the second public node
1214 pub bitcoin_signature_2: Signature,
1215 /// The actual announcement
1216 pub contents: UnsignedChannelAnnouncement,
1219 /// The unsigned part of a [`channel_update`] message.
1221 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1222 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1223 pub struct UnsignedChannelUpdate {
1224 /// The genesis hash of the blockchain where the channel is to be opened
1225 pub chain_hash: ChainHash,
1226 /// The short channel ID
1227 pub short_channel_id: u64,
1228 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1230 /// Flags pertaining to this message.
1231 pub message_flags: u8,
1232 /// Flags pertaining to the channel, including to which direction in the channel this update
1233 /// applies and whether the direction is currently able to forward HTLCs.
1234 pub channel_flags: u8,
1235 /// The number of blocks such that if:
1236 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1237 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1238 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1239 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1240 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1241 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1242 /// constructing the route.
1243 pub cltv_expiry_delta: u16,
1244 /// The minimum HTLC size incoming to sender, in milli-satoshi
1245 pub htlc_minimum_msat: u64,
1246 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1248 /// This used to be optional.
1249 pub htlc_maximum_msat: u64,
1250 /// The base HTLC fee charged by sender, in milli-satoshi
1251 pub fee_base_msat: u32,
1252 /// The amount to fee multiplier, in micro-satoshi
1253 pub fee_proportional_millionths: u32,
1254 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1257 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1258 pub excess_data: Vec<u8>,
1260 /// A [`channel_update`] message to be sent to or received from a peer.
1262 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1263 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1264 pub struct ChannelUpdate {
1265 /// A signature of the channel update
1266 pub signature: Signature,
1267 /// The actual channel update
1268 pub contents: UnsignedChannelUpdate,
1271 /// A [`query_channel_range`] message is used to query a peer for channel
1272 /// UTXOs in a range of blocks. The recipient of a query makes a best
1273 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1276 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1277 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1278 pub struct QueryChannelRange {
1279 /// The genesis hash of the blockchain being queried
1280 pub chain_hash: ChainHash,
1281 /// The height of the first block for the channel UTXOs being queried
1282 pub first_blocknum: u32,
1283 /// The number of blocks to include in the query results
1284 pub number_of_blocks: u32,
1287 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1290 /// Multiple `reply_channel_range` messages can be sent in reply
1291 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1292 /// best effort to respond based on their local network view which may
1293 /// not be a perfect view of the network. The `short_channel_id`s in the
1294 /// reply are encoded. We only support `encoding_type=0` uncompressed
1295 /// serialization and do not support `encoding_type=1` zlib serialization.
1297 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1298 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1299 pub struct ReplyChannelRange {
1300 /// The genesis hash of the blockchain being queried
1301 pub chain_hash: ChainHash,
1302 /// The height of the first block in the range of the reply
1303 pub first_blocknum: u32,
1304 /// The number of blocks included in the range of the reply
1305 pub number_of_blocks: u32,
1306 /// True when this is the final reply for a query
1307 pub sync_complete: bool,
1308 /// The `short_channel_id`s in the channel range
1309 pub short_channel_ids: Vec<u64>,
1312 /// A [`query_short_channel_ids`] message is used to query a peer for
1313 /// routing gossip messages related to one or more `short_channel_id`s.
1315 /// The query recipient will reply with the latest, if available,
1316 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1317 /// it maintains for the requested `short_channel_id`s followed by a
1318 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1319 /// this query are encoded. We only support `encoding_type=0` uncompressed
1320 /// serialization and do not support `encoding_type=1` zlib serialization.
1322 /// [`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
1323 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1324 pub struct QueryShortChannelIds {
1325 /// The genesis hash of the blockchain being queried
1326 pub chain_hash: ChainHash,
1327 /// The short_channel_ids that are being queried
1328 pub short_channel_ids: Vec<u64>,
1331 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1332 /// message. The query recipient makes a best
1333 /// effort to respond based on their local network view which may not be
1334 /// a perfect view of the network.
1336 /// [`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
1337 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1338 pub struct ReplyShortChannelIdsEnd {
1339 /// The genesis hash of the blockchain that was queried
1340 pub chain_hash: ChainHash,
1341 /// Indicates if the query recipient maintains up-to-date channel
1342 /// information for the `chain_hash`
1343 pub full_information: bool,
1346 /// A [`gossip_timestamp_filter`] message is used by a node to request
1347 /// gossip relay for messages in the requested time range when the
1348 /// `gossip_queries` feature has been negotiated.
1350 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1351 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1352 pub struct GossipTimestampFilter {
1353 /// The genesis hash of the blockchain for channel and node information
1354 pub chain_hash: ChainHash,
1355 /// The starting unix timestamp
1356 pub first_timestamp: u32,
1357 /// The range of information in seconds
1358 pub timestamp_range: u32,
1361 /// Encoding type for data compression of collections in gossip queries.
1363 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1364 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1366 Uncompressed = 0x00,
1369 /// Used to put an error message in a [`LightningError`].
1370 #[derive(Clone, Debug, Hash, PartialEq)]
1371 pub enum ErrorAction {
1372 /// The peer took some action which made us think they were useless. Disconnect them.
1374 /// An error message which we should make an effort to send before we disconnect.
1375 msg: Option<ErrorMessage>
1377 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1378 DisconnectPeerWithWarning {
1379 /// A warning message which we should make an effort to send before we disconnect.
1380 msg: WarningMessage,
1382 /// The peer did something harmless that we weren't able to process, just log and ignore
1383 // New code should *not* use this. New code must use IgnoreAndLog, below!
1385 /// The peer did something harmless that we weren't able to meaningfully process.
1386 /// If the error is logged, log it at the given level.
1387 IgnoreAndLog(logger::Level),
1388 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1389 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1390 /// our own channel announcements.
1391 IgnoreDuplicateGossip,
1392 /// The peer did something incorrect. Tell them.
1394 /// The message to send.
1397 /// The peer did something incorrect. Tell them without closing any channels.
1398 SendWarningMessage {
1399 /// The message to send.
1400 msg: WarningMessage,
1401 /// The peer may have done something harmless that we weren't able to meaningfully process,
1402 /// though we should still tell them about it.
1403 /// If this event is logged, log it at the given level.
1404 log_level: logger::Level,
1408 /// An Err type for failure to process messages.
1409 #[derive(Clone, Debug)]
1410 pub struct LightningError {
1411 /// A human-readable message describing the error
1413 /// The action which should be taken against the offending peer.
1414 pub action: ErrorAction,
1417 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1418 /// transaction updates if they were pending.
1419 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1420 pub struct CommitmentUpdate {
1421 /// `update_add_htlc` messages which should be sent
1422 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1423 /// `update_fulfill_htlc` messages which should be sent
1424 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1425 /// `update_fail_htlc` messages which should be sent
1426 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1427 /// `update_fail_malformed_htlc` messages which should be sent
1428 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1429 /// An `update_fee` message which should be sent
1430 pub update_fee: Option<UpdateFee>,
1431 /// A `commitment_signed` message which should be sent
1432 pub commitment_signed: CommitmentSigned,
1435 /// A trait to describe an object which can receive channel messages.
1437 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1438 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1439 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1441 /// Handle an incoming `open_channel` message from the given peer.
1442 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1443 /// Handle an incoming `open_channel2` message from the given peer.
1444 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1445 /// Handle an incoming `accept_channel` message from the given peer.
1446 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1447 /// Handle an incoming `accept_channel2` message from the given peer.
1448 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1449 /// Handle an incoming `funding_created` message from the given peer.
1450 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1451 /// Handle an incoming `funding_signed` message from the given peer.
1452 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1453 /// Handle an incoming `channel_ready` message from the given peer.
1454 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1457 /// Handle an incoming `shutdown` message from the given peer.
1458 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1459 /// Handle an incoming `closing_signed` message from the given peer.
1460 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1463 /// Handle an incoming `stfu` message from the given peer.
1464 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1467 /// Handle an incoming `splice` message from the given peer.
1469 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1470 /// Handle an incoming `splice_ack` message from the given peer.
1472 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1473 /// Handle an incoming `splice_locked` message from the given peer.
1475 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1477 // Interactive channel construction
1478 /// Handle an incoming `tx_add_input message` from the given peer.
1479 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1480 /// Handle an incoming `tx_add_output` message from the given peer.
1481 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1482 /// Handle an incoming `tx_remove_input` message from the given peer.
1483 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1484 /// Handle an incoming `tx_remove_output` message from the given peer.
1485 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1486 /// Handle an incoming `tx_complete message` from the given peer.
1487 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1488 /// Handle an incoming `tx_signatures` message from the given peer.
1489 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1490 /// Handle an incoming `tx_init_rbf` message from the given peer.
1491 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1492 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1493 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1494 /// Handle an incoming `tx_abort message` from the given peer.
1495 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1498 /// Handle an incoming `update_add_htlc` message from the given peer.
1499 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1500 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1501 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1502 /// Handle an incoming `update_fail_htlc` message from the given peer.
1503 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1504 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1505 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1506 /// Handle an incoming `commitment_signed` message from the given peer.
1507 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1508 /// Handle an incoming `revoke_and_ack` message from the given peer.
1509 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1511 /// Handle an incoming `update_fee` message from the given peer.
1512 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1514 // Channel-to-announce:
1515 /// Handle an incoming `announcement_signatures` message from the given peer.
1516 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1518 // Connection loss/reestablish:
1519 /// Indicates a connection to the peer failed/an existing connection was lost.
1520 fn peer_disconnected(&self, their_node_id: &PublicKey);
1522 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1524 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1525 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1526 /// message handlers may still wish to communicate with this peer.
1527 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1528 /// Handle an incoming `channel_reestablish` message from the given peer.
1529 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1531 /// Handle an incoming `channel_update` message from the given peer.
1532 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1535 /// Handle an incoming `error` message from the given peer.
1536 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1538 // Handler information:
1539 /// Gets the node feature flags which this handler itself supports. All available handlers are
1540 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1541 /// which are broadcasted in our [`NodeAnnouncement`] message.
1542 fn provided_node_features(&self) -> NodeFeatures;
1544 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1545 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1546 /// which are sent in our [`Init`] message.
1548 /// Note that this method is called before [`Self::peer_connected`].
1549 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1551 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1553 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1554 /// connecting to peers.
1555 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1558 /// A trait to describe an object which can receive routing messages.
1560 /// # Implementor DoS Warnings
1562 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1563 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1564 /// repeated disk I/O for queries accessing different parts of the network graph.
1565 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1566 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1567 /// `false` or returning an `Err` otherwise.
1568 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1569 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1570 /// or returning an `Err` otherwise.
1571 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1572 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1573 /// `false` or returning an `Err` otherwise.
1574 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1575 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1576 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1577 /// for a single channel.
1578 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1579 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1580 /// the node *after* the provided pubkey and including up to one announcement immediately
1581 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1582 /// If `None` is provided for `starting_point`, we start at the first node.
1583 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1584 /// Called when a connection is established with a peer. This can be used to
1585 /// perform routing table synchronization using a strategy defined by the
1588 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1589 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1590 /// message handlers may still wish to communicate with this peer.
1591 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1592 /// Handles the reply of a query we initiated to learn about channels
1593 /// for a given range of blocks. We can expect to receive one or more
1594 /// replies to a single query.
1595 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1596 /// Handles the reply of a query we initiated asking for routing gossip
1597 /// messages for a list of channels. We should receive this message when
1598 /// a node has completed its best effort to send us the pertaining routing
1599 /// gossip messages.
1600 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1601 /// Handles when a peer asks us to send a list of `short_channel_id`s
1602 /// for the requested range of blocks.
1603 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1604 /// Handles when a peer asks us to send routing gossip messages for a
1605 /// list of `short_channel_id`s.
1606 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1608 // Handler queueing status:
1609 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1610 /// pending some async action. While there is no guarantee of the rate of future messages, the
1611 /// caller should seek to reduce the rate of new gossip messages handled, especially
1612 /// [`ChannelAnnouncement`]s.
1613 fn processing_queue_high(&self) -> bool;
1615 // Handler information:
1616 /// Gets the node feature flags which this handler itself supports. All available handlers are
1617 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1618 /// which are broadcasted in our [`NodeAnnouncement`] message.
1619 fn provided_node_features(&self) -> NodeFeatures;
1620 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1621 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1622 /// which are sent in our [`Init`] message.
1624 /// Note that this method is called before [`Self::peer_connected`].
1625 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1628 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1629 pub trait OnionMessageHandler {
1630 /// Handle an incoming `onion_message` message from the given peer.
1631 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1633 /// Returns the next pending onion message for the peer with the given node id.
1634 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1636 /// Called when a connection is established with a peer. Can be used to track which peers
1637 /// advertise onion message support and are online.
1639 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1640 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1641 /// message handlers may still wish to communicate with this peer.
1642 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1644 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1645 /// drop and refuse to forward onion messages to this peer.
1646 fn peer_disconnected(&self, their_node_id: &PublicKey);
1648 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1649 /// to drop any buffered onion messages intended for prospective peers.
1650 fn timer_tick_occurred(&self);
1652 // Handler information:
1653 /// Gets the node feature flags which this handler itself supports. All available handlers are
1654 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1655 /// which are broadcasted in our [`NodeAnnouncement`] message.
1656 fn provided_node_features(&self) -> NodeFeatures;
1658 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1659 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1660 /// which are sent in our [`Init`] message.
1662 /// Note that this method is called before [`Self::peer_connected`].
1663 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1667 #[cfg_attr(test, derive(Debug, PartialEq))]
1668 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1669 /// the payment is associated with an invoice.
1670 pub struct FinalOnionHopData {
1671 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1672 /// Because it is generated by the recipient and included in the invoice, it also provides
1673 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1674 pub payment_secret: PaymentSecret,
1675 /// The intended total amount that this payment is for.
1677 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1678 pub total_msat: u64,
1681 mod fuzzy_internal_msgs {
1682 use bitcoin::secp256k1::PublicKey;
1683 use crate::blinded_path::payment::{PaymentConstraints, PaymentContext, PaymentRelay};
1684 use crate::ln::types::{PaymentPreimage, PaymentSecret};
1685 use crate::ln::features::BlindedHopFeatures;
1686 use super::{FinalOnionHopData, TrampolineOnionPacket};
1688 #[allow(unused_imports)]
1689 use crate::prelude::*;
1691 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1692 // them from untrusted input):
1694 pub enum InboundOnionPayload {
1696 short_channel_id: u64,
1697 /// The value, in msat, of the payment after this hop's fee is deducted.
1698 amt_to_forward: u64,
1699 outgoing_cltv_value: u32,
1702 payment_data: Option<FinalOnionHopData>,
1703 payment_metadata: Option<Vec<u8>>,
1704 keysend_preimage: Option<PaymentPreimage>,
1705 custom_tlvs: Vec<(u64, Vec<u8>)>,
1706 sender_intended_htlc_amt_msat: u64,
1707 cltv_expiry_height: u32,
1710 short_channel_id: u64,
1711 payment_relay: PaymentRelay,
1712 payment_constraints: PaymentConstraints,
1713 features: BlindedHopFeatures,
1714 intro_node_blinding_point: Option<PublicKey>,
1717 sender_intended_htlc_amt_msat: u64,
1719 cltv_expiry_height: u32,
1720 payment_secret: PaymentSecret,
1721 payment_constraints: PaymentConstraints,
1722 payment_context: PaymentContext,
1723 intro_node_blinding_point: Option<PublicKey>,
1724 keysend_preimage: Option<PaymentPreimage>,
1725 custom_tlvs: Vec<(u64, Vec<u8>)>,
1729 pub(crate) enum OutboundOnionPayload<'a> {
1731 short_channel_id: u64,
1732 /// The value, in msat, of the payment after this hop's fee is deducted.
1733 amt_to_forward: u64,
1734 outgoing_cltv_value: u32,
1737 TrampolineEntrypoint {
1738 amt_to_forward: u64,
1739 outgoing_cltv_value: u32,
1740 multipath_trampoline_data: Option<FinalOnionHopData>,
1741 trampoline_packet: TrampolineOnionPacket,
1744 payment_data: Option<FinalOnionHopData>,
1745 payment_metadata: Option<&'a Vec<u8>>,
1746 keysend_preimage: Option<PaymentPreimage>,
1747 custom_tlvs: &'a Vec<(u64, Vec<u8>)>,
1748 sender_intended_htlc_amt_msat: u64,
1749 cltv_expiry_height: u32,
1752 encrypted_tlvs: &'a Vec<u8>,
1753 intro_node_blinding_point: Option<PublicKey>,
1756 sender_intended_htlc_amt_msat: u64,
1758 cltv_expiry_height: u32,
1759 encrypted_tlvs: &'a Vec<u8>,
1760 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1761 keysend_preimage: Option<PaymentPreimage>,
1762 custom_tlvs: &'a Vec<(u64, Vec<u8>)>,
1766 pub(crate) enum OutboundTrampolinePayload {
1769 /// The value, in msat, of the payment after this hop's fee is deducted.
1770 amt_to_forward: u64,
1771 outgoing_cltv_value: u32,
1772 /// The node id to which the trampoline node must find a route
1773 outgoing_node_id: PublicKey,
1777 pub struct DecodedOnionErrorPacket {
1778 pub(crate) hmac: [u8; 32],
1779 pub(crate) failuremsg: Vec<u8>,
1780 pub(crate) pad: Vec<u8>,
1784 pub use self::fuzzy_internal_msgs::*;
1785 #[cfg(not(fuzzing))]
1786 pub(crate) use self::fuzzy_internal_msgs::*;
1788 /// BOLT 4 onion packet including hop data for the next peer.
1789 #[derive(Clone, Hash, PartialEq, Eq)]
1790 pub struct OnionPacket {
1791 /// BOLT 4 version number.
1793 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1794 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1795 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1796 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1798 pub public_key: Result<PublicKey, secp256k1::Error>,
1799 /// 1300 bytes encrypted payload for the next hop.
1800 pub hop_data: [u8; 20*65],
1801 /// HMAC to verify the integrity of hop_data.
1805 impl onion_utils::Packet for OnionPacket {
1806 type Data = onion_utils::FixedSizeOnionPacket;
1807 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1810 public_key: Ok(pubkey),
1811 hop_data: hop_data.0,
1817 impl fmt::Debug for OnionPacket {
1818 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1819 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1823 /// BOLT 4 onion packet including hop data for the next peer.
1824 #[derive(Clone, Hash, PartialEq, Eq)]
1825 pub struct TrampolineOnionPacket {
1826 /// Bolt 04 version number
1828 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1829 pub public_key: PublicKey,
1830 /// Encrypted payload for the next hop
1832 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1833 // 1300 bytes. The expected default is 650 bytes.
1834 // TODO: if 650 ends up being the most common size, optimize this to be:
1835 // enum { SixFifty([u8; 650]), VarLen(Vec<u8>) }
1836 pub hop_data: Vec<u8>,
1837 /// HMAC to verify the integrity of hop_data
1841 impl onion_utils::Packet for TrampolineOnionPacket {
1842 type Data = Vec<u8>;
1843 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1853 impl Writeable for TrampolineOnionPacket {
1854 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1855 self.version.write(w)?;
1856 self.public_key.write(w)?;
1857 w.write_all(&self.hop_data)?;
1858 self.hmac.write(w)?;
1863 impl LengthReadable for TrampolineOnionPacket {
1864 fn read<R: LengthRead>(r: &mut R) -> Result<Self, DecodeError> {
1865 let version = Readable::read(r)?;
1866 let public_key = Readable::read(r)?;
1868 let hop_data_len = r.total_bytes().saturating_sub(66); // 1 (version) + 33 (pubkey) + 32 (HMAC) = 66
1869 let mut rd = FixedLengthReader::new(r, hop_data_len);
1870 let hop_data = WithoutLength::<Vec<u8>>::read(&mut rd)?.0;
1872 let hmac = Readable::read(r)?;
1874 Ok(TrampolineOnionPacket {
1883 impl Debug for TrampolineOnionPacket {
1884 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1885 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1889 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1890 pub(crate) struct OnionErrorPacket {
1891 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1892 // (TODO) We limit it in decode to much lower...
1893 pub(crate) data: Vec<u8>,
1896 impl fmt::Display for DecodeError {
1897 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1899 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1900 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1901 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1902 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1903 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1904 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1905 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1906 DecodeError::DangerousValue => f.write_str("Value would be dangerous to continue execution with"),
1911 impl From<io::Error> for DecodeError {
1912 fn from(e: io::Error) -> Self {
1913 if e.kind() == io::ErrorKind::UnexpectedEof {
1914 DecodeError::ShortRead
1916 DecodeError::Io(e.kind())
1921 impl Writeable for AcceptChannel {
1922 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1923 self.common_fields.temporary_channel_id.write(w)?;
1924 self.common_fields.dust_limit_satoshis.write(w)?;
1925 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1926 self.channel_reserve_satoshis.write(w)?;
1927 self.common_fields.htlc_minimum_msat.write(w)?;
1928 self.common_fields.minimum_depth.write(w)?;
1929 self.common_fields.to_self_delay.write(w)?;
1930 self.common_fields.max_accepted_htlcs.write(w)?;
1931 self.common_fields.funding_pubkey.write(w)?;
1932 self.common_fields.revocation_basepoint.write(w)?;
1933 self.common_fields.payment_basepoint.write(w)?;
1934 self.common_fields.delayed_payment_basepoint.write(w)?;
1935 self.common_fields.htlc_basepoint.write(w)?;
1936 self.common_fields.first_per_commitment_point.write(w)?;
1937 #[cfg(not(taproot))]
1938 encode_tlv_stream!(w, {
1939 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1940 (1, self.common_fields.channel_type, option),
1943 encode_tlv_stream!(w, {
1944 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1945 (1, self.common_fields.channel_type, option),
1946 (4, self.next_local_nonce, option),
1952 impl Readable for AcceptChannel {
1953 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1954 let temporary_channel_id: ChannelId = Readable::read(r)?;
1955 let dust_limit_satoshis: u64 = Readable::read(r)?;
1956 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1957 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1958 let htlc_minimum_msat: u64 = Readable::read(r)?;
1959 let minimum_depth: u32 = Readable::read(r)?;
1960 let to_self_delay: u16 = Readable::read(r)?;
1961 let max_accepted_htlcs: u16 = Readable::read(r)?;
1962 let funding_pubkey: PublicKey = Readable::read(r)?;
1963 let revocation_basepoint: PublicKey = Readable::read(r)?;
1964 let payment_basepoint: PublicKey = Readable::read(r)?;
1965 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1966 let htlc_basepoint: PublicKey = Readable::read(r)?;
1967 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1969 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1970 let mut channel_type: Option<ChannelTypeFeatures> = None;
1971 #[cfg(not(taproot))]
1972 decode_tlv_stream!(r, {
1973 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1974 (1, channel_type, option),
1977 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1979 decode_tlv_stream!(r, {
1980 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1981 (1, channel_type, option),
1982 (4, next_local_nonce, option),
1986 common_fields: CommonAcceptChannelFields {
1987 temporary_channel_id,
1988 dust_limit_satoshis,
1989 max_htlc_value_in_flight_msat,
1995 revocation_basepoint,
1997 delayed_payment_basepoint,
1999 first_per_commitment_point,
2000 shutdown_scriptpubkey,
2003 channel_reserve_satoshis,
2010 impl Writeable for AcceptChannelV2 {
2011 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2012 self.common_fields.temporary_channel_id.write(w)?;
2013 self.funding_satoshis.write(w)?;
2014 self.common_fields.dust_limit_satoshis.write(w)?;
2015 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2016 self.common_fields.htlc_minimum_msat.write(w)?;
2017 self.common_fields.minimum_depth.write(w)?;
2018 self.common_fields.to_self_delay.write(w)?;
2019 self.common_fields.max_accepted_htlcs.write(w)?;
2020 self.common_fields.funding_pubkey.write(w)?;
2021 self.common_fields.revocation_basepoint.write(w)?;
2022 self.common_fields.payment_basepoint.write(w)?;
2023 self.common_fields.delayed_payment_basepoint.write(w)?;
2024 self.common_fields.htlc_basepoint.write(w)?;
2025 self.common_fields.first_per_commitment_point.write(w)?;
2026 self.second_per_commitment_point.write(w)?;
2028 encode_tlv_stream!(w, {
2029 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2030 (1, self.common_fields.channel_type, option),
2031 (2, self.require_confirmed_inputs, option),
2037 impl Readable for AcceptChannelV2 {
2038 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2039 let temporary_channel_id: ChannelId = Readable::read(r)?;
2040 let funding_satoshis: u64 = Readable::read(r)?;
2041 let dust_limit_satoshis: u64 = Readable::read(r)?;
2042 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2043 let htlc_minimum_msat: u64 = Readable::read(r)?;
2044 let minimum_depth: u32 = Readable::read(r)?;
2045 let to_self_delay: u16 = Readable::read(r)?;
2046 let max_accepted_htlcs: u16 = Readable::read(r)?;
2047 let funding_pubkey: PublicKey = Readable::read(r)?;
2048 let revocation_basepoint: PublicKey = Readable::read(r)?;
2049 let payment_basepoint: PublicKey = Readable::read(r)?;
2050 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2051 let htlc_basepoint: PublicKey = Readable::read(r)?;
2052 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2053 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2055 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2056 let mut channel_type: Option<ChannelTypeFeatures> = None;
2057 let mut require_confirmed_inputs: Option<()> = None;
2058 decode_tlv_stream!(r, {
2059 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2060 (1, channel_type, option),
2061 (2, require_confirmed_inputs, option),
2064 Ok(AcceptChannelV2 {
2065 common_fields: CommonAcceptChannelFields {
2066 temporary_channel_id,
2067 dust_limit_satoshis,
2068 max_htlc_value_in_flight_msat,
2074 revocation_basepoint,
2076 delayed_payment_basepoint,
2078 first_per_commitment_point,
2079 shutdown_scriptpubkey,
2083 second_per_commitment_point,
2084 require_confirmed_inputs,
2089 impl_writeable_msg!(Stfu, {
2094 impl_writeable_msg!(Splice, {
2098 funding_feerate_perkw,
2103 impl_writeable_msg!(SpliceAck, {
2110 impl_writeable_msg!(SpliceLocked, {
2114 impl_writeable_msg!(TxAddInput, {
2122 impl_writeable_msg!(TxAddOutput, {
2129 impl_writeable_msg!(TxRemoveInput, {
2134 impl_writeable_msg!(TxRemoveOutput, {
2139 impl_writeable_msg!(TxComplete, {
2143 impl_writeable_msg!(TxSignatures, {
2148 (0, funding_outpoint_sig, option),
2151 impl_writeable_msg!(TxInitRbf, {
2154 feerate_sat_per_1000_weight,
2156 (0, funding_output_contribution, option),
2159 impl_writeable_msg!(TxAckRbf, {
2162 (0, funding_output_contribution, option),
2165 impl_writeable_msg!(TxAbort, {
2170 impl_writeable_msg!(AnnouncementSignatures, {
2177 impl_writeable_msg!(ChannelReestablish, {
2179 next_local_commitment_number,
2180 next_remote_commitment_number,
2181 your_last_per_commitment_secret,
2182 my_current_per_commitment_point,
2184 (0, next_funding_txid, option),
2187 impl_writeable_msg!(ClosingSigned,
2188 { channel_id, fee_satoshis, signature },
2189 { (1, fee_range, option) }
2192 impl_writeable!(ClosingSignedFeeRange, {
2197 #[cfg(not(taproot))]
2198 impl_writeable_msg!(CommitmentSigned, {
2205 impl_writeable_msg!(CommitmentSigned, {
2210 (2, partial_signature_with_nonce, option)
2213 impl_writeable!(DecodedOnionErrorPacket, {
2219 #[cfg(not(taproot))]
2220 impl_writeable_msg!(FundingCreated, {
2221 temporary_channel_id,
2223 funding_output_index,
2227 impl_writeable_msg!(FundingCreated, {
2228 temporary_channel_id,
2230 funding_output_index,
2233 (2, partial_signature_with_nonce, option),
2234 (4, next_local_nonce, option)
2237 #[cfg(not(taproot))]
2238 impl_writeable_msg!(FundingSigned, {
2244 impl_writeable_msg!(FundingSigned, {
2248 (2, partial_signature_with_nonce, option)
2251 impl_writeable_msg!(ChannelReady, {
2253 next_per_commitment_point,
2255 (1, short_channel_id_alias, option),
2258 impl Writeable for Init {
2259 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2260 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2261 // our relevant feature bits. This keeps us compatible with old nodes.
2262 self.features.write_up_to_13(w)?;
2263 self.features.write(w)?;
2264 encode_tlv_stream!(w, {
2265 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2266 (3, self.remote_network_address, option),
2272 impl Readable for Init {
2273 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2274 let global_features: InitFeatures = Readable::read(r)?;
2275 let features: InitFeatures = Readable::read(r)?;
2276 let mut remote_network_address: Option<SocketAddress> = None;
2277 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2278 decode_tlv_stream!(r, {
2279 (1, networks, option),
2280 (3, remote_network_address, option)
2283 features: features | global_features,
2284 networks: networks.map(|n| n.0),
2285 remote_network_address,
2290 impl Writeable for OpenChannel {
2291 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2292 self.common_fields.chain_hash.write(w)?;
2293 self.common_fields.temporary_channel_id.write(w)?;
2294 self.common_fields.funding_satoshis.write(w)?;
2295 self.push_msat.write(w)?;
2296 self.common_fields.dust_limit_satoshis.write(w)?;
2297 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2298 self.channel_reserve_satoshis.write(w)?;
2299 self.common_fields.htlc_minimum_msat.write(w)?;
2300 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2301 self.common_fields.to_self_delay.write(w)?;
2302 self.common_fields.max_accepted_htlcs.write(w)?;
2303 self.common_fields.funding_pubkey.write(w)?;
2304 self.common_fields.revocation_basepoint.write(w)?;
2305 self.common_fields.payment_basepoint.write(w)?;
2306 self.common_fields.delayed_payment_basepoint.write(w)?;
2307 self.common_fields.htlc_basepoint.write(w)?;
2308 self.common_fields.first_per_commitment_point.write(w)?;
2309 self.common_fields.channel_flags.write(w)?;
2310 encode_tlv_stream!(w, {
2311 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2312 (1, self.common_fields.channel_type, option),
2318 impl Readable for OpenChannel {
2319 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2320 let chain_hash: ChainHash = Readable::read(r)?;
2321 let temporary_channel_id: ChannelId = Readable::read(r)?;
2322 let funding_satoshis: u64 = Readable::read(r)?;
2323 let push_msat: u64 = Readable::read(r)?;
2324 let dust_limit_satoshis: u64 = Readable::read(r)?;
2325 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2326 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2327 let htlc_minimum_msat: u64 = Readable::read(r)?;
2328 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2329 let to_self_delay: u16 = Readable::read(r)?;
2330 let max_accepted_htlcs: u16 = Readable::read(r)?;
2331 let funding_pubkey: PublicKey = Readable::read(r)?;
2332 let revocation_basepoint: PublicKey = Readable::read(r)?;
2333 let payment_basepoint: PublicKey = Readable::read(r)?;
2334 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2335 let htlc_basepoint: PublicKey = Readable::read(r)?;
2336 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2337 let channel_flags: u8 = Readable::read(r)?;
2339 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2340 let mut channel_type: Option<ChannelTypeFeatures> = None;
2341 decode_tlv_stream!(r, {
2342 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2343 (1, channel_type, option),
2346 common_fields: CommonOpenChannelFields {
2348 temporary_channel_id,
2350 dust_limit_satoshis,
2351 max_htlc_value_in_flight_msat,
2353 commitment_feerate_sat_per_1000_weight,
2357 revocation_basepoint,
2359 delayed_payment_basepoint,
2361 first_per_commitment_point,
2363 shutdown_scriptpubkey,
2367 channel_reserve_satoshis,
2372 impl Writeable for OpenChannelV2 {
2373 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2374 self.common_fields.chain_hash.write(w)?;
2375 self.common_fields.temporary_channel_id.write(w)?;
2376 self.funding_feerate_sat_per_1000_weight.write(w)?;
2377 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2378 self.common_fields.funding_satoshis.write(w)?;
2379 self.common_fields.dust_limit_satoshis.write(w)?;
2380 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2381 self.common_fields.htlc_minimum_msat.write(w)?;
2382 self.common_fields.to_self_delay.write(w)?;
2383 self.common_fields.max_accepted_htlcs.write(w)?;
2384 self.locktime.write(w)?;
2385 self.common_fields.funding_pubkey.write(w)?;
2386 self.common_fields.revocation_basepoint.write(w)?;
2387 self.common_fields.payment_basepoint.write(w)?;
2388 self.common_fields.delayed_payment_basepoint.write(w)?;
2389 self.common_fields.htlc_basepoint.write(w)?;
2390 self.common_fields.first_per_commitment_point.write(w)?;
2391 self.second_per_commitment_point.write(w)?;
2392 self.common_fields.channel_flags.write(w)?;
2393 encode_tlv_stream!(w, {
2394 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2395 (1, self.common_fields.channel_type, option),
2396 (2, self.require_confirmed_inputs, option),
2402 impl Readable for OpenChannelV2 {
2403 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2404 let chain_hash: ChainHash = Readable::read(r)?;
2405 let temporary_channel_id: ChannelId = Readable::read(r)?;
2406 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2407 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2408 let funding_satoshis: u64 = Readable::read(r)?;
2409 let dust_limit_satoshis: u64 = Readable::read(r)?;
2410 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2411 let htlc_minimum_msat: u64 = Readable::read(r)?;
2412 let to_self_delay: u16 = Readable::read(r)?;
2413 let max_accepted_htlcs: u16 = Readable::read(r)?;
2414 let locktime: u32 = Readable::read(r)?;
2415 let funding_pubkey: PublicKey = Readable::read(r)?;
2416 let revocation_basepoint: PublicKey = Readable::read(r)?;
2417 let payment_basepoint: PublicKey = Readable::read(r)?;
2418 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2419 let htlc_basepoint: PublicKey = Readable::read(r)?;
2420 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2421 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2422 let channel_flags: u8 = Readable::read(r)?;
2424 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2425 let mut channel_type: Option<ChannelTypeFeatures> = None;
2426 let mut require_confirmed_inputs: Option<()> = None;
2427 decode_tlv_stream!(r, {
2428 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2429 (1, channel_type, option),
2430 (2, require_confirmed_inputs, option),
2433 common_fields: CommonOpenChannelFields {
2435 temporary_channel_id,
2437 dust_limit_satoshis,
2438 max_htlc_value_in_flight_msat,
2440 commitment_feerate_sat_per_1000_weight,
2444 revocation_basepoint,
2446 delayed_payment_basepoint,
2448 first_per_commitment_point,
2450 shutdown_scriptpubkey,
2453 funding_feerate_sat_per_1000_weight,
2455 second_per_commitment_point,
2456 require_confirmed_inputs,
2461 #[cfg(not(taproot))]
2462 impl_writeable_msg!(RevokeAndACK, {
2464 per_commitment_secret,
2465 next_per_commitment_point
2469 impl_writeable_msg!(RevokeAndACK, {
2471 per_commitment_secret,
2472 next_per_commitment_point
2474 (4, next_local_nonce, option)
2477 impl_writeable_msg!(Shutdown, {
2482 impl_writeable_msg!(UpdateFailHTLC, {
2488 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2495 impl_writeable_msg!(UpdateFee, {
2500 impl_writeable_msg!(UpdateFulfillHTLC, {
2506 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2507 // serialization format in a way which assumes we know the total serialized length/message end
2509 impl_writeable!(OnionErrorPacket, {
2513 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2514 // serialization format in a way which assumes we know the total serialized length/message end
2516 impl Writeable for OnionPacket {
2517 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2518 self.version.write(w)?;
2519 match self.public_key {
2520 Ok(pubkey) => pubkey.write(w)?,
2521 Err(_) => [0u8;33].write(w)?,
2523 w.write_all(&self.hop_data)?;
2524 self.hmac.write(w)?;
2529 impl Readable for OnionPacket {
2530 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2532 version: Readable::read(r)?,
2534 let mut buf = [0u8;33];
2535 r.read_exact(&mut buf)?;
2536 PublicKey::from_slice(&buf)
2538 hop_data: Readable::read(r)?,
2539 hmac: Readable::read(r)?,
2544 impl_writeable_msg!(UpdateAddHTLC, {
2550 onion_routing_packet,
2552 (0, blinding_point, option),
2553 (65537, skimmed_fee_msat, option)
2556 impl Readable for OnionMessage {
2557 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2558 let blinding_point: PublicKey = Readable::read(r)?;
2559 let len: u16 = Readable::read(r)?;
2560 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2561 let onion_routing_packet: onion_message::packet::Packet =
2562 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2565 onion_routing_packet,
2570 impl Writeable for OnionMessage {
2571 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2572 self.blinding_point.write(w)?;
2573 let onion_packet_len = self.onion_routing_packet.serialized_length();
2574 (onion_packet_len as u16).write(w)?;
2575 self.onion_routing_packet.write(w)?;
2580 impl Writeable for FinalOnionHopData {
2581 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2582 self.payment_secret.0.write(w)?;
2583 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2587 impl Readable for FinalOnionHopData {
2588 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2589 let secret: [u8; 32] = Readable::read(r)?;
2590 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2591 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2595 impl<'a> Writeable for OutboundOnionPayload<'a> {
2596 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2598 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2599 _encode_varint_length_prefixed_tlv!(w, {
2600 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2601 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2602 (6, short_channel_id, required)
2605 Self::TrampolineEntrypoint {
2606 amt_to_forward, outgoing_cltv_value, ref multipath_trampoline_data,
2607 ref trampoline_packet
2609 _encode_varint_length_prefixed_tlv!(w, {
2610 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2611 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2612 (8, multipath_trampoline_data, option),
2613 (20, trampoline_packet, required)
2617 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2618 cltv_expiry_height, ref custom_tlvs,
2620 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2621 // to reject any reserved types in the experimental range if new ones are ever
2623 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2624 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2625 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2626 _encode_varint_length_prefixed_tlv!(w, {
2627 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2628 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2629 (8, payment_data, option),
2630 (16, payment_metadata.map(|m| WithoutLength(m)), option)
2631 }, custom_tlvs.iter());
2633 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2634 _encode_varint_length_prefixed_tlv!(w, {
2635 (10, **encrypted_tlvs, required_vec),
2636 (12, intro_node_blinding_point, option)
2639 Self::BlindedReceive {
2640 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2641 intro_node_blinding_point, keysend_preimage, ref custom_tlvs,
2643 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2644 // to reject any reserved types in the experimental range if new ones are ever
2646 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2647 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2648 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2649 _encode_varint_length_prefixed_tlv!(w, {
2650 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2651 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2652 (10, **encrypted_tlvs, required_vec),
2653 (12, intro_node_blinding_point, option),
2654 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2655 }, custom_tlvs.iter());
2662 impl Writeable for OutboundTrampolinePayload {
2663 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2665 Self::Forward { amt_to_forward, outgoing_cltv_value, outgoing_node_id } => {
2666 _encode_varint_length_prefixed_tlv!(w, {
2667 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2668 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2669 (14, outgoing_node_id, required)
2678 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2679 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2680 let (update_add_blinding_point, node_signer) = args;
2683 let mut cltv_value = None;
2684 let mut short_id: Option<u64> = None;
2685 let mut payment_data: Option<FinalOnionHopData> = None;
2686 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2687 let mut intro_node_blinding_point = None;
2688 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2689 let mut total_msat = None;
2690 let mut keysend_preimage: Option<PaymentPreimage> = None;
2691 let mut custom_tlvs = Vec::new();
2693 let tlv_len = BigSize::read(r)?;
2694 let rd = FixedLengthReader::new(r, tlv_len.0);
2695 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2696 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2697 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2698 (6, short_id, option),
2699 (8, payment_data, option),
2700 (10, encrypted_tlvs_opt, option),
2701 (12, intro_node_blinding_point, option),
2702 (16, payment_metadata, option),
2703 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2704 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2705 (5482373484, keysend_preimage, option)
2706 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2707 if msg_type < 1 << 16 { return Ok(false) }
2708 let mut value = Vec::new();
2709 msg_reader.read_to_end(&mut value)?;
2710 custom_tlvs.push((msg_type, value));
2714 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2715 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2716 return Err(DecodeError::InvalidValue)
2719 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2720 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2721 return Err(DecodeError::InvalidValue)
2723 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2724 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2725 .map_err(|_| DecodeError::InvalidValue)?;
2726 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2727 let mut s = Cursor::new(&enc_tlvs);
2728 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2729 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2730 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2731 short_channel_id, payment_relay, payment_constraints, features
2733 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2734 keysend_preimage.is_some()
2736 return Err(DecodeError::InvalidValue)
2738 Ok(Self::BlindedForward {
2741 payment_constraints,
2743 intro_node_blinding_point,
2746 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2747 payment_secret, payment_constraints, payment_context
2749 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2750 Ok(Self::BlindedReceive {
2751 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2752 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2753 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2755 payment_constraints,
2757 intro_node_blinding_point,
2763 } else if let Some(short_channel_id) = short_id {
2764 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2765 total_msat.is_some()
2766 { return Err(DecodeError::InvalidValue) }
2769 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2770 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2773 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2774 return Err(DecodeError::InvalidValue)
2776 if let Some(data) = &payment_data {
2777 if data.total_msat > MAX_VALUE_MSAT {
2778 return Err(DecodeError::InvalidValue);
2783 payment_metadata: payment_metadata.map(|w| w.0),
2785 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2786 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2793 impl Writeable for Ping {
2794 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2795 self.ponglen.write(w)?;
2796 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2801 impl Readable for Ping {
2802 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2804 ponglen: Readable::read(r)?,
2806 let byteslen = Readable::read(r)?;
2807 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2814 impl Writeable for Pong {
2815 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2816 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2821 impl Readable for Pong {
2822 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2825 let byteslen = Readable::read(r)?;
2826 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2833 impl Writeable for UnsignedChannelAnnouncement {
2834 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2835 self.features.write(w)?;
2836 self.chain_hash.write(w)?;
2837 self.short_channel_id.write(w)?;
2838 self.node_id_1.write(w)?;
2839 self.node_id_2.write(w)?;
2840 self.bitcoin_key_1.write(w)?;
2841 self.bitcoin_key_2.write(w)?;
2842 w.write_all(&self.excess_data[..])?;
2847 impl Readable for UnsignedChannelAnnouncement {
2848 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2850 features: Readable::read(r)?,
2851 chain_hash: Readable::read(r)?,
2852 short_channel_id: Readable::read(r)?,
2853 node_id_1: Readable::read(r)?,
2854 node_id_2: Readable::read(r)?,
2855 bitcoin_key_1: Readable::read(r)?,
2856 bitcoin_key_2: Readable::read(r)?,
2857 excess_data: read_to_end(r)?,
2862 impl_writeable!(ChannelAnnouncement, {
2865 bitcoin_signature_1,
2866 bitcoin_signature_2,
2870 impl Writeable for UnsignedChannelUpdate {
2871 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2872 self.chain_hash.write(w)?;
2873 self.short_channel_id.write(w)?;
2874 self.timestamp.write(w)?;
2875 // Thw low bit of message_flags used to indicate the presence of `htlc_maximum_msat`, and
2877 (self.message_flags | 1).write(w)?;
2878 self.channel_flags.write(w)?;
2879 self.cltv_expiry_delta.write(w)?;
2880 self.htlc_minimum_msat.write(w)?;
2881 self.fee_base_msat.write(w)?;
2882 self.fee_proportional_millionths.write(w)?;
2883 self.htlc_maximum_msat.write(w)?;
2884 w.write_all(&self.excess_data[..])?;
2889 impl Readable for UnsignedChannelUpdate {
2890 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2892 chain_hash: Readable::read(r)?,
2893 short_channel_id: Readable::read(r)?,
2894 timestamp: Readable::read(r)?,
2895 message_flags: Readable::read(r)?,
2896 channel_flags: Readable::read(r)?,
2897 cltv_expiry_delta: Readable::read(r)?,
2898 htlc_minimum_msat: Readable::read(r)?,
2899 fee_base_msat: Readable::read(r)?,
2900 fee_proportional_millionths: Readable::read(r)?,
2901 htlc_maximum_msat: Readable::read(r)?,
2902 excess_data: read_to_end(r)?,
2904 if res.message_flags & 1 != 1 {
2905 // The `must_be_one` flag should be set (historically it indicated the presence of the
2906 // `htlc_maximum_msat` field, which is now required).
2907 Err(DecodeError::InvalidValue)
2914 impl_writeable!(ChannelUpdate, {
2919 impl Writeable for ErrorMessage {
2920 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2921 self.channel_id.write(w)?;
2922 (self.data.len() as u16).write(w)?;
2923 w.write_all(self.data.as_bytes())?;
2928 impl Readable for ErrorMessage {
2929 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2931 channel_id: Readable::read(r)?,
2933 let sz: usize = <u16 as Readable>::read(r)? as usize;
2934 let mut data = Vec::with_capacity(sz);
2936 r.read_exact(&mut data)?;
2937 match String::from_utf8(data) {
2939 Err(_) => return Err(DecodeError::InvalidValue),
2946 impl Writeable for WarningMessage {
2947 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2948 self.channel_id.write(w)?;
2949 (self.data.len() as u16).write(w)?;
2950 w.write_all(self.data.as_bytes())?;
2955 impl Readable for WarningMessage {
2956 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2958 channel_id: Readable::read(r)?,
2960 let sz: usize = <u16 as Readable>::read(r)? as usize;
2961 let mut data = Vec::with_capacity(sz);
2963 r.read_exact(&mut data)?;
2964 match String::from_utf8(data) {
2966 Err(_) => return Err(DecodeError::InvalidValue),
2973 impl Writeable for UnsignedNodeAnnouncement {
2974 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2975 self.features.write(w)?;
2976 self.timestamp.write(w)?;
2977 self.node_id.write(w)?;
2978 w.write_all(&self.rgb)?;
2979 self.alias.write(w)?;
2981 let mut addr_len = 0;
2982 for addr in self.addresses.iter() {
2983 addr_len += 1 + addr.len();
2985 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2986 for addr in self.addresses.iter() {
2989 w.write_all(&self.excess_address_data[..])?;
2990 w.write_all(&self.excess_data[..])?;
2995 impl Readable for UnsignedNodeAnnouncement {
2996 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2997 let features: NodeFeatures = Readable::read(r)?;
2998 let timestamp: u32 = Readable::read(r)?;
2999 let node_id: NodeId = Readable::read(r)?;
3000 let mut rgb = [0; 3];
3001 r.read_exact(&mut rgb)?;
3002 let alias: NodeAlias = Readable::read(r)?;
3004 let addr_len: u16 = Readable::read(r)?;
3005 let mut addresses: Vec<SocketAddress> = Vec::new();
3006 let mut addr_readpos = 0;
3007 let mut excess = false;
3008 let mut excess_byte = 0;
3010 if addr_len <= addr_readpos { break; }
3011 match Readable::read(r) {
3013 if addr_len < addr_readpos + 1 + addr.len() {
3014 return Err(DecodeError::BadLengthDescriptor);
3016 addr_readpos += (1 + addr.len()) as u16;
3017 addresses.push(addr);
3019 Ok(Err(unknown_descriptor)) => {
3021 excess_byte = unknown_descriptor;
3024 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
3025 Err(e) => return Err(e),
3029 let mut excess_data = vec![];
3030 let excess_address_data = if addr_readpos < addr_len {
3031 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
3032 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
3034 excess_address_data[0] = excess_byte;
3039 excess_data.push(excess_byte);
3043 excess_data.extend(read_to_end(r)?.iter());
3044 Ok(UnsignedNodeAnnouncement {
3051 excess_address_data,
3057 impl_writeable!(NodeAnnouncement, {
3062 impl Readable for QueryShortChannelIds {
3063 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3064 let chain_hash: ChainHash = Readable::read(r)?;
3066 let encoding_len: u16 = Readable::read(r)?;
3067 let encoding_type: u8 = Readable::read(r)?;
3069 // Must be encoding_type=0 uncompressed serialization. We do not
3070 // support encoding_type=1 zlib serialization.
3071 if encoding_type != EncodingType::Uncompressed as u8 {
3072 return Err(DecodeError::UnsupportedCompression);
3075 // We expect the encoding_len to always includes the 1-byte
3076 // encoding_type and that short_channel_ids are 8-bytes each
3077 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3078 return Err(DecodeError::InvalidValue);
3081 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3082 // less the 1-byte encoding_type
3083 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3084 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3085 for _ in 0..short_channel_id_count {
3086 short_channel_ids.push(Readable::read(r)?);
3089 Ok(QueryShortChannelIds {
3096 impl Writeable for QueryShortChannelIds {
3097 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3098 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
3099 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3101 self.chain_hash.write(w)?;
3102 encoding_len.write(w)?;
3104 // We only support type=0 uncompressed serialization
3105 (EncodingType::Uncompressed as u8).write(w)?;
3107 for scid in self.short_channel_ids.iter() {
3115 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3120 impl QueryChannelRange {
3121 /// Calculates the overflow safe ending block height for the query.
3123 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3124 pub fn end_blocknum(&self) -> u32 {
3125 match self.first_blocknum.checked_add(self.number_of_blocks) {
3126 Some(block) => block,
3127 None => u32::max_value(),
3132 impl_writeable_msg!(QueryChannelRange, {
3138 impl Readable for ReplyChannelRange {
3139 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3140 let chain_hash: ChainHash = Readable::read(r)?;
3141 let first_blocknum: u32 = Readable::read(r)?;
3142 let number_of_blocks: u32 = Readable::read(r)?;
3143 let sync_complete: bool = Readable::read(r)?;
3145 let encoding_len: u16 = Readable::read(r)?;
3146 let encoding_type: u8 = Readable::read(r)?;
3148 // Must be encoding_type=0 uncompressed serialization. We do not
3149 // support encoding_type=1 zlib serialization.
3150 if encoding_type != EncodingType::Uncompressed as u8 {
3151 return Err(DecodeError::UnsupportedCompression);
3154 // We expect the encoding_len to always includes the 1-byte
3155 // encoding_type and that short_channel_ids are 8-bytes each
3156 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3157 return Err(DecodeError::InvalidValue);
3160 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3161 // less the 1-byte encoding_type
3162 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3163 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3164 for _ in 0..short_channel_id_count {
3165 short_channel_ids.push(Readable::read(r)?);
3168 Ok(ReplyChannelRange {
3178 impl Writeable for ReplyChannelRange {
3179 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3180 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3181 self.chain_hash.write(w)?;
3182 self.first_blocknum.write(w)?;
3183 self.number_of_blocks.write(w)?;
3184 self.sync_complete.write(w)?;
3186 encoding_len.write(w)?;
3187 (EncodingType::Uncompressed as u8).write(w)?;
3188 for scid in self.short_channel_ids.iter() {
3196 impl_writeable_msg!(GossipTimestampFilter, {
3204 use bitcoin::{Amount, Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3205 use hex::DisplayHex;
3206 use crate::ln::types::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
3207 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3208 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
3209 use crate::ln::msgs::SocketAddress;
3210 use crate::routing::gossip::{NodeAlias, NodeId};
3211 use crate::util::ser::{BigSize, FixedLengthReader, Hostname, LengthReadable, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
3212 use crate::util::test_utils;
3214 use bitcoin::hashes::hex::FromHex;
3215 use bitcoin::address::Address;
3216 use bitcoin::network::Network;
3217 use bitcoin::blockdata::constants::ChainHash;
3218 use bitcoin::blockdata::script::Builder;
3219 use bitcoin::blockdata::opcodes;
3220 use bitcoin::hash_types::Txid;
3221 use bitcoin::locktime::absolute::LockTime;
3222 use bitcoin::transaction::Version;
3224 use bitcoin::secp256k1::{PublicKey,SecretKey};
3225 use bitcoin::secp256k1::{Secp256k1, Message};
3227 use crate::io::{self, Cursor};
3228 use crate::prelude::*;
3229 use core::str::FromStr;
3230 use crate::chain::transaction::OutPoint;
3232 #[cfg(feature = "std")]
3233 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3234 #[cfg(feature = "std")]
3235 use crate::ln::msgs::SocketAddressParseError;
3238 fn encoding_channel_reestablish() {
3240 let secp_ctx = Secp256k1::new();
3241 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3244 let cr = msgs::ChannelReestablish {
3245 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]),
3246 next_local_commitment_number: 3,
3247 next_remote_commitment_number: 4,
3248 your_last_per_commitment_secret: [9;32],
3249 my_current_per_commitment_point: public_key,
3250 next_funding_txid: None,
3253 let encoded_value = cr.encode();
3257 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
3258 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3259 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3260 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
3261 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
3267 fn encoding_channel_reestablish_with_next_funding_txid() {
3269 let secp_ctx = Secp256k1::new();
3270 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3273 let cr = msgs::ChannelReestablish {
3274 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]),
3275 next_local_commitment_number: 3,
3276 next_remote_commitment_number: 4,
3277 your_last_per_commitment_secret: [9;32],
3278 my_current_per_commitment_point: public_key,
3279 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3280 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,
3284 let encoded_value = cr.encode();
3288 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
3289 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3290 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3291 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
3292 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
3293 0, // Type (next_funding_txid)
3295 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
3300 macro_rules! get_keys_from {
3301 ($slice: expr, $secp_ctx: expr) => {
3303 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3304 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3310 macro_rules! get_sig_on {
3311 ($privkey: expr, $ctx: expr, $string: expr) => {
3313 let sighash = Message::from_digest_slice(&$string.into_bytes()[..]).unwrap();
3314 $ctx.sign_ecdsa(&sighash, &$privkey)
3320 fn encoding_announcement_signatures() {
3321 let secp_ctx = Secp256k1::new();
3322 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3323 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3324 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3325 let announcement_signatures = msgs::AnnouncementSignatures {
3326 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]),
3327 short_channel_id: 2316138423780173,
3328 node_signature: sig_1,
3329 bitcoin_signature: sig_2,
3332 let encoded_value = announcement_signatures.encode();
3333 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3336 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3337 let secp_ctx = Secp256k1::new();
3338 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3339 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3340 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3341 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3342 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3343 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3344 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3345 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3346 let mut features = ChannelFeatures::empty();
3347 if unknown_features_bits {
3348 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3350 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3352 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3353 short_channel_id: 2316138423780173,
3354 node_id_1: NodeId::from_pubkey(&pubkey_1),
3355 node_id_2: NodeId::from_pubkey(&pubkey_2),
3356 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3357 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3358 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3360 let channel_announcement = msgs::ChannelAnnouncement {
3361 node_signature_1: sig_1,
3362 node_signature_2: sig_2,
3363 bitcoin_signature_1: sig_3,
3364 bitcoin_signature_2: sig_4,
3365 contents: unsigned_channel_announcement,
3367 let encoded_value = channel_announcement.encode();
3368 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3369 if unknown_features_bits {
3370 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3372 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3374 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3375 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3377 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3379 assert_eq!(encoded_value, target_value);
3383 fn encoding_channel_announcement() {
3384 do_encoding_channel_announcement(true, false);
3385 do_encoding_channel_announcement(false, true);
3386 do_encoding_channel_announcement(false, false);
3387 do_encoding_channel_announcement(true, true);
3390 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) {
3391 let secp_ctx = Secp256k1::new();
3392 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3393 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3394 let features = if unknown_features_bits {
3395 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3397 // Set to some features we may support
3398 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3400 let mut addresses = Vec::new();
3402 addresses.push(SocketAddress::TcpIpV4 {
3403 addr: [255, 254, 253, 252],
3408 addresses.push(SocketAddress::TcpIpV6 {
3409 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3414 addresses.push(msgs::SocketAddress::OnionV2(
3415 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3419 addresses.push(msgs::SocketAddress::OnionV3 {
3420 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],
3427 addresses.push(SocketAddress::Hostname {
3428 hostname: Hostname::try_from(String::from("host")).unwrap(),
3432 let mut addr_len = 0;
3433 for addr in &addresses {
3434 addr_len += addr.len() + 1;
3436 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3438 timestamp: 20190119,
3439 node_id: NodeId::from_pubkey(&pubkey_1),
3441 alias: NodeAlias([16;32]),
3443 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() },
3444 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() },
3446 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3447 let node_announcement = msgs::NodeAnnouncement {
3449 contents: unsigned_node_announcement,
3451 let encoded_value = node_announcement.encode();
3452 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3453 if unknown_features_bits {
3454 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3456 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3458 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3459 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3461 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3464 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3467 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3470 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3473 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3475 if excess_address_data {
3476 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3479 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3481 assert_eq!(encoded_value, target_value);
3485 fn encoding_node_announcement() {
3486 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3487 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3488 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3489 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3490 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3491 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3492 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3493 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3494 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3495 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3498 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3499 let secp_ctx = Secp256k1::new();
3500 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3501 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3502 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3503 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3504 short_channel_id: 2316138423780173,
3505 timestamp: 20190119,
3506 message_flags: 1, // Only must_be_one
3507 channel_flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3508 cltv_expiry_delta: 144,
3509 htlc_minimum_msat: 1000000,
3510 htlc_maximum_msat: 131355275467161,
3511 fee_base_msat: 10000,
3512 fee_proportional_millionths: 20,
3513 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3515 let channel_update = msgs::ChannelUpdate {
3517 contents: unsigned_channel_update
3519 let encoded_value = channel_update.encode();
3520 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3521 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3522 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3523 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3524 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3526 let flag = target_value.last_mut().unwrap();
3530 let flag = target_value.last_mut().unwrap();
3531 *flag = *flag | 1 << 1;
3533 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3534 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3536 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3538 assert_eq!(encoded_value, target_value);
3542 fn encoding_channel_update() {
3543 do_encoding_channel_update(false, false, false);
3544 do_encoding_channel_update(false, false, true);
3545 do_encoding_channel_update(true, false, false);
3546 do_encoding_channel_update(true, false, true);
3547 do_encoding_channel_update(false, true, false);
3548 do_encoding_channel_update(false, true, true);
3549 do_encoding_channel_update(true, true, false);
3550 do_encoding_channel_update(true, true, true);
3553 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3554 let secp_ctx = Secp256k1::new();
3555 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3556 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3557 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3558 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3559 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3560 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3561 let open_channel = msgs::OpenChannel {
3562 common_fields: CommonOpenChannelFields {
3563 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3564 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3565 funding_satoshis: 1311768467284833366,
3566 dust_limit_satoshis: 3608586615801332854,
3567 max_htlc_value_in_flight_msat: 8517154655701053848,
3568 htlc_minimum_msat: 2316138423780173,
3569 commitment_feerate_sat_per_1000_weight: 821716,
3570 to_self_delay: 49340,
3571 max_accepted_htlcs: 49340,
3572 funding_pubkey: pubkey_1,
3573 revocation_basepoint: pubkey_2,
3574 payment_basepoint: pubkey_3,
3575 delayed_payment_basepoint: pubkey_4,
3576 htlc_basepoint: pubkey_5,
3577 first_per_commitment_point: pubkey_6,
3578 channel_flags: if random_bit { 1 << 5 } else { 0 },
3579 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3580 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3582 push_msat: 2536655962884945560,
3583 channel_reserve_satoshis: 8665828695742877976,
3585 let encoded_value = open_channel.encode();
3586 let mut target_value = Vec::new();
3587 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3588 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3590 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3592 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3595 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3598 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3600 assert_eq!(encoded_value, target_value);
3604 fn encoding_open_channel() {
3605 do_encoding_open_channel(false, false, false);
3606 do_encoding_open_channel(false, false, true);
3607 do_encoding_open_channel(false, true, false);
3608 do_encoding_open_channel(false, true, true);
3609 do_encoding_open_channel(true, false, false);
3610 do_encoding_open_channel(true, false, true);
3611 do_encoding_open_channel(true, true, false);
3612 do_encoding_open_channel(true, true, true);
3615 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3616 let secp_ctx = Secp256k1::new();
3617 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3618 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3619 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3620 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3621 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3622 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3623 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3624 let open_channelv2 = msgs::OpenChannelV2 {
3625 common_fields: CommonOpenChannelFields {
3626 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3627 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3628 commitment_feerate_sat_per_1000_weight: 821716,
3629 funding_satoshis: 1311768467284833366,
3630 dust_limit_satoshis: 3608586615801332854,
3631 max_htlc_value_in_flight_msat: 8517154655701053848,
3632 htlc_minimum_msat: 2316138423780173,
3633 to_self_delay: 49340,
3634 max_accepted_htlcs: 49340,
3635 funding_pubkey: pubkey_1,
3636 revocation_basepoint: pubkey_2,
3637 payment_basepoint: pubkey_3,
3638 delayed_payment_basepoint: pubkey_4,
3639 htlc_basepoint: pubkey_5,
3640 first_per_commitment_point: pubkey_6,
3641 channel_flags: if random_bit { 1 << 5 } else { 0 },
3642 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3643 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3645 funding_feerate_sat_per_1000_weight: 821716,
3646 locktime: 305419896,
3647 second_per_commitment_point: pubkey_7,
3648 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3650 let encoded_value = open_channelv2.encode();
3651 let mut target_value = Vec::new();
3652 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3653 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3654 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3655 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3656 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3657 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3658 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3659 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3660 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3661 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3662 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3663 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3664 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3665 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3666 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3667 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3668 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3669 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3672 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3674 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3677 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3680 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3682 if require_confirmed_inputs {
3683 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3685 assert_eq!(encoded_value, target_value);
3689 fn encoding_open_channelv2() {
3690 do_encoding_open_channelv2(false, false, false, false);
3691 do_encoding_open_channelv2(false, false, false, true);
3692 do_encoding_open_channelv2(false, false, true, false);
3693 do_encoding_open_channelv2(false, false, true, true);
3694 do_encoding_open_channelv2(false, true, false, false);
3695 do_encoding_open_channelv2(false, true, false, true);
3696 do_encoding_open_channelv2(false, true, true, false);
3697 do_encoding_open_channelv2(false, true, true, true);
3698 do_encoding_open_channelv2(true, false, false, false);
3699 do_encoding_open_channelv2(true, false, false, true);
3700 do_encoding_open_channelv2(true, false, true, false);
3701 do_encoding_open_channelv2(true, false, true, true);
3702 do_encoding_open_channelv2(true, true, false, false);
3703 do_encoding_open_channelv2(true, true, false, true);
3704 do_encoding_open_channelv2(true, true, true, false);
3705 do_encoding_open_channelv2(true, true, true, true);
3708 fn do_encoding_accept_channel(shutdown: bool) {
3709 let secp_ctx = Secp256k1::new();
3710 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3711 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3712 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3713 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3714 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3715 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3716 let accept_channel = msgs::AcceptChannel {
3717 common_fields: CommonAcceptChannelFields {
3718 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3719 dust_limit_satoshis: 1311768467284833366,
3720 max_htlc_value_in_flight_msat: 2536655962884945560,
3721 htlc_minimum_msat: 2316138423780173,
3722 minimum_depth: 821716,
3723 to_self_delay: 49340,
3724 max_accepted_htlcs: 49340,
3725 funding_pubkey: pubkey_1,
3726 revocation_basepoint: pubkey_2,
3727 payment_basepoint: pubkey_3,
3728 delayed_payment_basepoint: pubkey_4,
3729 htlc_basepoint: pubkey_5,
3730 first_per_commitment_point: pubkey_6,
3731 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3734 channel_reserve_satoshis: 3608586615801332854,
3736 next_local_nonce: None,
3738 let encoded_value = accept_channel.encode();
3739 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3741 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3743 assert_eq!(encoded_value, target_value);
3747 fn encoding_accept_channel() {
3748 do_encoding_accept_channel(false);
3749 do_encoding_accept_channel(true);
3752 fn do_encoding_accept_channelv2(shutdown: bool) {
3753 let secp_ctx = Secp256k1::new();
3754 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3755 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3756 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3757 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3758 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3759 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3760 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3761 let accept_channelv2 = msgs::AcceptChannelV2 {
3762 common_fields: CommonAcceptChannelFields {
3763 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3764 dust_limit_satoshis: 1311768467284833366,
3765 max_htlc_value_in_flight_msat: 2536655962884945560,
3766 htlc_minimum_msat: 2316138423780173,
3767 minimum_depth: 821716,
3768 to_self_delay: 49340,
3769 max_accepted_htlcs: 49340,
3770 funding_pubkey: pubkey_1,
3771 revocation_basepoint: pubkey_2,
3772 payment_basepoint: pubkey_3,
3773 delayed_payment_basepoint: pubkey_4,
3774 htlc_basepoint: pubkey_5,
3775 first_per_commitment_point: pubkey_6,
3776 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3779 funding_satoshis: 1311768467284833366,
3780 second_per_commitment_point: pubkey_7,
3781 require_confirmed_inputs: None,
3783 let encoded_value = accept_channelv2.encode();
3784 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3785 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3786 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3787 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3788 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3789 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3790 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3791 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3792 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3793 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3794 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3795 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3796 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3797 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3798 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3800 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3802 assert_eq!(encoded_value, target_value);
3806 fn encoding_accept_channelv2() {
3807 do_encoding_accept_channelv2(false);
3808 do_encoding_accept_channelv2(true);
3812 fn encoding_funding_created() {
3813 let secp_ctx = Secp256k1::new();
3814 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3815 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3816 let funding_created = msgs::FundingCreated {
3817 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3818 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3819 funding_output_index: 255,
3822 partial_signature_with_nonce: None,
3824 next_local_nonce: None,
3826 let encoded_value = funding_created.encode();
3827 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3828 assert_eq!(encoded_value, target_value);
3832 fn encoding_funding_signed() {
3833 let secp_ctx = Secp256k1::new();
3834 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3835 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3836 let funding_signed = msgs::FundingSigned {
3837 channel_id: ChannelId::from_bytes([2; 32]),
3840 partial_signature_with_nonce: None,
3842 let encoded_value = funding_signed.encode();
3843 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3844 assert_eq!(encoded_value, target_value);
3848 fn encoding_channel_ready() {
3849 let secp_ctx = Secp256k1::new();
3850 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3851 let channel_ready = msgs::ChannelReady {
3852 channel_id: ChannelId::from_bytes([2; 32]),
3853 next_per_commitment_point: pubkey_1,
3854 short_channel_id_alias: None,
3856 let encoded_value = channel_ready.encode();
3857 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3858 assert_eq!(encoded_value, target_value);
3862 fn encoding_splice() {
3863 let secp_ctx = Secp256k1::new();
3864 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3865 let splice = msgs::Splice {
3866 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3867 channel_id: ChannelId::from_bytes([2; 32]),
3868 relative_satoshis: 123456,
3869 funding_feerate_perkw: 2000,
3871 funding_pubkey: pubkey_1,
3873 let encoded_value = splice.encode();
3874 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3878 fn encoding_stfu() {
3879 let stfu = msgs::Stfu {
3880 channel_id: ChannelId::from_bytes([2; 32]),
3883 let encoded_value = stfu.encode();
3884 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3888 fn encoding_splice_ack() {
3889 let secp_ctx = Secp256k1::new();
3890 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3891 let splice = msgs::SpliceAck {
3892 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3893 channel_id: ChannelId::from_bytes([2; 32]),
3894 relative_satoshis: 123456,
3895 funding_pubkey: pubkey_1,
3897 let encoded_value = splice.encode();
3898 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3902 fn encoding_splice_locked() {
3903 let splice = msgs::SpliceLocked {
3904 channel_id: ChannelId::from_bytes([2; 32]),
3906 let encoded_value = splice.encode();
3907 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3911 fn encoding_tx_add_input() {
3912 let tx_add_input = msgs::TxAddInput {
3913 channel_id: ChannelId::from_bytes([2; 32]),
3914 serial_id: 4886718345,
3915 prevtx: TransactionU16LenLimited::new(Transaction {
3916 version: Version::TWO,
3917 lock_time: LockTime::ZERO,
3919 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3920 script_sig: ScriptBuf::new(),
3921 sequence: Sequence(0xfffffffd),
3922 witness: Witness::from_slice(&vec![
3923 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3924 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3928 value: Amount::from_sat(12704566),
3929 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload().script_pubkey(),
3932 value: Amount::from_sat(245148),
3933 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload().script_pubkey(),
3937 prevtx_out: 305419896,
3938 sequence: 305419896,
3940 let encoded_value = tx_add_input.encode();
3941 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3942 assert_eq!(encoded_value, target_value);
3946 fn encoding_tx_add_output() {
3947 let tx_add_output = msgs::TxAddOutput {
3948 channel_id: ChannelId::from_bytes([2; 32]),
3949 serial_id: 4886718345,
3951 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload().script_pubkey(),
3953 let encoded_value = tx_add_output.encode();
3954 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3955 assert_eq!(encoded_value, target_value);
3959 fn encoding_tx_remove_input() {
3960 let tx_remove_input = msgs::TxRemoveInput {
3961 channel_id: ChannelId::from_bytes([2; 32]),
3962 serial_id: 4886718345,
3964 let encoded_value = tx_remove_input.encode();
3965 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3966 assert_eq!(encoded_value, target_value);
3970 fn encoding_tx_remove_output() {
3971 let tx_remove_output = msgs::TxRemoveOutput {
3972 channel_id: ChannelId::from_bytes([2; 32]),
3973 serial_id: 4886718345,
3975 let encoded_value = tx_remove_output.encode();
3976 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3977 assert_eq!(encoded_value, target_value);
3981 fn encoding_tx_complete() {
3982 let tx_complete = msgs::TxComplete {
3983 channel_id: ChannelId::from_bytes([2; 32]),
3985 let encoded_value = tx_complete.encode();
3986 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3987 assert_eq!(encoded_value, target_value);
3991 fn encoding_tx_signatures() {
3992 let secp_ctx = Secp256k1::new();
3993 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3994 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3996 let tx_signatures = msgs::TxSignatures {
3997 channel_id: ChannelId::from_bytes([2; 32]),
3998 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
4000 Witness::from_slice(&vec![
4001 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
4002 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
4003 Witness::from_slice(&vec![
4004 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
4005 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
4007 funding_outpoint_sig: Some(sig_1),
4009 let encoded_value = tx_signatures.encode();
4010 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
4011 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
4012 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
4014 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
4015 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
4016 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
4017 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
4018 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
4019 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
4021 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
4022 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
4023 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
4024 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
4025 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
4026 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
4027 target_value.append(&mut <Vec<u8>>::from_hex("0040").unwrap()); // type and len (64)
4028 target_value.append(&mut <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap());
4029 assert_eq!(encoded_value, target_value);
4032 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4033 let tx_init_rbf = msgs::TxInitRbf {
4034 channel_id: ChannelId::from_bytes([2; 32]),
4035 locktime: 305419896,
4036 feerate_sat_per_1000_weight: 20190119,
4037 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4039 let encoded_value = tx_init_rbf.encode();
4040 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
4041 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
4042 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
4043 if let Some((_, target)) = funding_value_with_hex_target {
4044 target_value.push(0x00); // Type
4045 target_value.push(target.len() as u8 / 2); // Length
4046 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4048 assert_eq!(encoded_value, target_value);
4052 fn encoding_tx_init_rbf() {
4053 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
4054 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
4055 do_encoding_tx_init_rbf(None);
4058 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4059 let tx_ack_rbf = msgs::TxAckRbf {
4060 channel_id: ChannelId::from_bytes([2; 32]),
4061 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4063 let encoded_value = tx_ack_rbf.encode();
4064 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4065 if let Some((_, target)) = funding_value_with_hex_target {
4066 target_value.push(0x00); // Type
4067 target_value.push(target.len() as u8 / 2); // Length
4068 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4070 assert_eq!(encoded_value, target_value);
4074 fn encoding_tx_ack_rbf() {
4075 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
4076 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
4077 do_encoding_tx_ack_rbf(None);
4081 fn encoding_tx_abort() {
4082 let tx_abort = msgs::TxAbort {
4083 channel_id: ChannelId::from_bytes([2; 32]),
4084 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
4086 let encoded_value = tx_abort.encode();
4087 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
4088 assert_eq!(encoded_value, target_value);
4091 fn do_encoding_shutdown(script_type: u8) {
4092 let secp_ctx = Secp256k1::new();
4093 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4094 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
4095 let shutdown = msgs::Shutdown {
4096 channel_id: ChannelId::from_bytes([2; 32]),
4098 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
4099 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
4100 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
4101 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
4103 let encoded_value = shutdown.encode();
4104 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4105 if script_type == 1 {
4106 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
4107 } else if script_type == 2 {
4108 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
4109 } else if script_type == 3 {
4110 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
4111 } else if script_type == 4 {
4112 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
4114 assert_eq!(encoded_value, target_value);
4118 fn encoding_shutdown() {
4119 do_encoding_shutdown(1);
4120 do_encoding_shutdown(2);
4121 do_encoding_shutdown(3);
4122 do_encoding_shutdown(4);
4126 fn encoding_closing_signed() {
4127 let secp_ctx = Secp256k1::new();
4128 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4129 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4130 let closing_signed = msgs::ClosingSigned {
4131 channel_id: ChannelId::from_bytes([2; 32]),
4132 fee_satoshis: 2316138423780173,
4136 let encoded_value = closing_signed.encode();
4137 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4138 assert_eq!(encoded_value, target_value);
4139 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4141 let closing_signed_with_range = msgs::ClosingSigned {
4142 channel_id: ChannelId::from_bytes([2; 32]),
4143 fee_satoshis: 2316138423780173,
4145 fee_range: Some(msgs::ClosingSignedFeeRange {
4146 min_fee_satoshis: 0xdeadbeef,
4147 max_fee_satoshis: 0x1badcafe01234567,
4150 let encoded_value_with_range = closing_signed_with_range.encode();
4151 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4152 assert_eq!(encoded_value_with_range, target_value_with_range);
4153 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4154 closing_signed_with_range);
4158 fn encoding_update_add_htlc() {
4159 let secp_ctx = Secp256k1::new();
4160 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4161 let onion_routing_packet = msgs::OnionPacket {
4163 public_key: Ok(pubkey_1),
4164 hop_data: [1; 20*65],
4167 let update_add_htlc = msgs::UpdateAddHTLC {
4168 channel_id: ChannelId::from_bytes([2; 32]),
4169 htlc_id: 2316138423780173,
4170 amount_msat: 3608586615801332854,
4171 payment_hash: PaymentHash([1; 32]),
4172 cltv_expiry: 821716,
4173 onion_routing_packet,
4174 skimmed_fee_msat: None,
4175 blinding_point: None,
4177 let encoded_value = update_add_htlc.encode();
4178 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4179 assert_eq!(encoded_value, target_value);
4183 fn encoding_update_fulfill_htlc() {
4184 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4185 channel_id: ChannelId::from_bytes([2; 32]),
4186 htlc_id: 2316138423780173,
4187 payment_preimage: PaymentPreimage([1; 32]),
4189 let encoded_value = update_fulfill_htlc.encode();
4190 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4191 assert_eq!(encoded_value, target_value);
4195 fn encoding_update_fail_htlc() {
4196 let reason = OnionErrorPacket {
4197 data: [1; 32].to_vec(),
4199 let update_fail_htlc = msgs::UpdateFailHTLC {
4200 channel_id: ChannelId::from_bytes([2; 32]),
4201 htlc_id: 2316138423780173,
4204 let encoded_value = update_fail_htlc.encode();
4205 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4206 assert_eq!(encoded_value, target_value);
4210 fn encoding_update_fail_malformed_htlc() {
4211 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4212 channel_id: ChannelId::from_bytes([2; 32]),
4213 htlc_id: 2316138423780173,
4214 sha256_of_onion: [1; 32],
4217 let encoded_value = update_fail_malformed_htlc.encode();
4218 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4219 assert_eq!(encoded_value, target_value);
4222 fn do_encoding_commitment_signed(htlcs: bool) {
4223 let secp_ctx = Secp256k1::new();
4224 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4225 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4226 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4227 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4228 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4229 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4230 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4231 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4232 let commitment_signed = msgs::CommitmentSigned {
4233 channel_id: ChannelId::from_bytes([2; 32]),
4235 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4237 partial_signature_with_nonce: None,
4239 let encoded_value = commitment_signed.encode();
4240 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4242 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4244 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4246 assert_eq!(encoded_value, target_value);
4250 fn encoding_commitment_signed() {
4251 do_encoding_commitment_signed(true);
4252 do_encoding_commitment_signed(false);
4256 fn encoding_revoke_and_ack() {
4257 let secp_ctx = Secp256k1::new();
4258 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4259 let raa = msgs::RevokeAndACK {
4260 channel_id: ChannelId::from_bytes([2; 32]),
4261 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],
4262 next_per_commitment_point: pubkey_1,
4264 next_local_nonce: None,
4266 let encoded_value = raa.encode();
4267 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4268 assert_eq!(encoded_value, target_value);
4272 fn encoding_update_fee() {
4273 let update_fee = msgs::UpdateFee {
4274 channel_id: ChannelId::from_bytes([2; 32]),
4275 feerate_per_kw: 20190119,
4277 let encoded_value = update_fee.encode();
4278 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4279 assert_eq!(encoded_value, target_value);
4283 fn encoding_init() {
4284 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4285 assert_eq!(msgs::Init {
4286 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4287 networks: Some(vec![mainnet_hash]),
4288 remote_network_address: None,
4289 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4290 assert_eq!(msgs::Init {
4291 features: InitFeatures::from_le_bytes(vec![0xFF]),
4293 remote_network_address: None,
4294 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4295 assert_eq!(msgs::Init {
4296 features: InitFeatures::from_le_bytes(vec![]),
4297 networks: Some(vec![mainnet_hash]),
4298 remote_network_address: None,
4299 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4300 assert_eq!(msgs::Init {
4301 features: InitFeatures::from_le_bytes(vec![]),
4302 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4303 remote_network_address: None,
4304 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4305 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4306 networks: Some(vec![mainnet_hash]),
4307 remote_network_address: Some(SocketAddress::TcpIpV4 {
4308 addr: [127, 0, 0, 1],
4312 let encoded_value = init_msg.encode();
4313 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4314 assert_eq!(encoded_value, target_value);
4315 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4319 fn encoding_error() {
4320 let error = msgs::ErrorMessage {
4321 channel_id: ChannelId::from_bytes([2; 32]),
4322 data: String::from("rust-lightning"),
4324 let encoded_value = error.encode();
4325 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4326 assert_eq!(encoded_value, target_value);
4330 fn encoding_warning() {
4331 let error = msgs::WarningMessage {
4332 channel_id: ChannelId::from_bytes([2; 32]),
4333 data: String::from("rust-lightning"),
4335 let encoded_value = error.encode();
4336 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4337 assert_eq!(encoded_value, target_value);
4341 fn encoding_ping() {
4342 let ping = msgs::Ping {
4346 let encoded_value = ping.encode();
4347 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4348 assert_eq!(encoded_value, target_value);
4352 fn encoding_pong() {
4353 let pong = msgs::Pong {
4356 let encoded_value = pong.encode();
4357 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4358 assert_eq!(encoded_value, target_value);
4362 fn encoding_nonfinal_onion_hop_data() {
4363 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4364 short_channel_id: 0xdeadbeef1bad1dea,
4365 amt_to_forward: 0x0badf00d01020304,
4366 outgoing_cltv_value: 0xffffffff,
4368 let encoded_value = outbound_msg.encode();
4369 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4370 assert_eq!(encoded_value, target_value);
4372 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4373 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4374 if let msgs::InboundOnionPayload::Forward {
4375 short_channel_id, amt_to_forward, outgoing_cltv_value
4377 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4378 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4379 assert_eq!(outgoing_cltv_value, 0xffffffff);
4380 } else { panic!(); }
4384 fn encoding_final_onion_hop_data() {
4385 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4387 payment_metadata: None,
4388 keysend_preimage: None,
4389 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4390 cltv_expiry_height: 0xffffffff,
4391 custom_tlvs: &vec![],
4393 let encoded_value = outbound_msg.encode();
4394 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4395 assert_eq!(encoded_value, target_value);
4397 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4398 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4399 if let msgs::InboundOnionPayload::Receive {
4400 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4402 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4403 assert_eq!(cltv_expiry_height, 0xffffffff);
4404 } else { panic!(); }
4408 fn encoding_final_onion_hop_data_with_secret() {
4409 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4410 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4411 payment_data: Some(FinalOnionHopData {
4412 payment_secret: expected_payment_secret,
4413 total_msat: 0x1badca1f
4415 payment_metadata: None,
4416 keysend_preimage: None,
4417 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4418 cltv_expiry_height: 0xffffffff,
4419 custom_tlvs: &vec![],
4421 let encoded_value = outbound_msg.encode();
4422 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4423 assert_eq!(encoded_value, target_value);
4425 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4426 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4427 if let msgs::InboundOnionPayload::Receive {
4428 payment_data: Some(FinalOnionHopData {
4430 total_msat: 0x1badca1f
4432 sender_intended_htlc_amt_msat, cltv_expiry_height,
4433 payment_metadata: None,
4434 keysend_preimage: None,
4437 assert_eq!(payment_secret, expected_payment_secret);
4438 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4439 assert_eq!(cltv_expiry_height, 0xffffffff);
4440 assert_eq!(custom_tlvs, vec![]);
4441 } else { panic!(); }
4445 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4446 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4448 let bad_type_range_tlvs = vec![
4449 ((1 << 16) - 4, vec![42]),
4450 ((1 << 16) - 2, vec![42; 32]),
4452 let mut msg = msgs::OutboundOnionPayload::Receive {
4454 payment_metadata: None,
4455 keysend_preimage: None,
4456 custom_tlvs: &bad_type_range_tlvs,
4457 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4458 cltv_expiry_height: 0xffffffff,
4460 let encoded_value = msg.encode();
4461 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4462 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4463 let good_type_range_tlvs = vec![
4464 ((1 << 16) - 3, vec![42]),
4465 ((1 << 16) - 1, vec![42; 32]),
4467 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4468 *custom_tlvs = &good_type_range_tlvs;
4470 let encoded_value = msg.encode();
4471 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4473 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4479 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4480 let expected_custom_tlvs = vec![
4481 (5482373483, vec![0x12, 0x34]),
4482 (5482373487, vec![0x42u8; 8]),
4484 let msg = msgs::OutboundOnionPayload::Receive {
4486 payment_metadata: None,
4487 keysend_preimage: None,
4488 custom_tlvs: &expected_custom_tlvs,
4489 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4490 cltv_expiry_height: 0xffffffff,
4492 let encoded_value = msg.encode();
4493 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4494 assert_eq!(encoded_value, target_value);
4495 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4496 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4497 if let msgs::InboundOnionPayload::Receive {
4499 payment_metadata: None,
4500 keysend_preimage: None,
4502 sender_intended_htlc_amt_msat,
4503 cltv_expiry_height: outgoing_cltv_value,
4506 assert_eq!(custom_tlvs, expected_custom_tlvs);
4507 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4508 assert_eq!(outgoing_cltv_value, 0xffffffff);
4509 } else { panic!(); }
4513 fn encoding_final_onion_hop_data_with_trampoline_packet() {
4514 let secp_ctx = Secp256k1::new();
4515 let (_private_key, public_key) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4517 let compressed_public_key = public_key.serialize();
4518 assert_eq!(compressed_public_key.len(), 33);
4520 let trampoline_packet = TrampolineOnionPacket {
4523 hop_data: vec![1; 650], // this should be the standard encoded length
4526 let encoded_trampoline_packet = trampoline_packet.encode();
4527 assert_eq!(encoded_trampoline_packet.len(), 716);
4529 { // verify that a codec round trip works
4530 let mut reader = Cursor::new(&encoded_trampoline_packet);
4531 let mut trampoline_packet_reader = FixedLengthReader::new(&mut reader, encoded_trampoline_packet.len() as u64);
4532 let decoded_trampoline_packet: TrampolineOnionPacket = <TrampolineOnionPacket as LengthReadable>::read(&mut trampoline_packet_reader).unwrap();
4533 assert_eq!(decoded_trampoline_packet.encode(), encoded_trampoline_packet);
4536 let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
4537 multipath_trampoline_data: None,
4538 amt_to_forward: 0x0badf00d01020304,
4539 outgoing_cltv_value: 0xffffffff,
4542 let encoded_payload = msg.encode();
4544 let trampoline_type_bytes = &encoded_payload[19..=19];
4545 let mut trampoline_type_cursor = Cursor::new(trampoline_type_bytes);
4546 let trampoline_type_big_size: BigSize = Readable::read(&mut trampoline_type_cursor).unwrap();
4547 assert_eq!(trampoline_type_big_size.0, 20);
4549 let trampoline_length_bytes = &encoded_payload[20..=22];
4550 let mut trampoline_length_cursor = Cursor::new(trampoline_length_bytes);
4551 let trampoline_length_big_size: BigSize = Readable::read(&mut trampoline_length_cursor).unwrap();
4552 assert_eq!(trampoline_length_big_size.0, encoded_trampoline_packet.len() as u64);
4556 fn encoding_final_onion_hop_data_with_eclair_trampoline_packet() {
4557 let public_key = PublicKey::from_slice(&<Vec<u8>>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()).unwrap();
4558 let hop_data = <Vec<u8>>::from_hex("cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4c").unwrap();
4559 let hmac_vector = <Vec<u8>>::from_hex("bb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4560 let mut hmac = [0; 32];
4561 hmac.copy_from_slice(&hmac_vector);
4563 let compressed_public_key = public_key.serialize();
4564 assert_eq!(compressed_public_key.len(), 33);
4566 let trampoline_packet = TrampolineOnionPacket {
4572 let encoded_trampoline_packet = trampoline_packet.encode();
4573 let expected_eclair_trampoline_packet = <Vec<u8>>::from_hex("0002eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4cbb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4574 assert_eq!(encoded_trampoline_packet, expected_eclair_trampoline_packet);
4578 fn query_channel_range_end_blocknum() {
4579 let tests: Vec<(u32, u32, u32)> = vec![
4580 (10000, 1500, 11500),
4581 (0, 0xffffffff, 0xffffffff),
4582 (1, 0xffffffff, 0xffffffff),
4585 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4586 let sut = msgs::QueryChannelRange {
4587 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4591 assert_eq!(sut.end_blocknum(), expected);
4596 fn encoding_query_channel_range() {
4597 let mut query_channel_range = msgs::QueryChannelRange {
4598 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4599 first_blocknum: 100000,
4600 number_of_blocks: 1500,
4602 let encoded_value = query_channel_range.encode();
4603 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4604 assert_eq!(encoded_value, target_value);
4606 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4607 assert_eq!(query_channel_range.first_blocknum, 100000);
4608 assert_eq!(query_channel_range.number_of_blocks, 1500);
4612 fn encoding_reply_channel_range() {
4613 do_encoding_reply_channel_range(0);
4614 do_encoding_reply_channel_range(1);
4617 fn do_encoding_reply_channel_range(encoding_type: u8) {
4618 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4619 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4620 let mut reply_channel_range = msgs::ReplyChannelRange {
4621 chain_hash: expected_chain_hash,
4622 first_blocknum: 756230,
4623 number_of_blocks: 1500,
4624 sync_complete: true,
4625 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4628 if encoding_type == 0 {
4629 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4630 let encoded_value = reply_channel_range.encode();
4631 assert_eq!(encoded_value, target_value);
4633 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4634 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4635 assert_eq!(reply_channel_range.first_blocknum, 756230);
4636 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4637 assert_eq!(reply_channel_range.sync_complete, true);
4638 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4639 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4640 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4642 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4643 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4644 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4649 fn encoding_query_short_channel_ids() {
4650 do_encoding_query_short_channel_ids(0);
4651 do_encoding_query_short_channel_ids(1);
4654 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4655 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4656 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4657 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4658 chain_hash: expected_chain_hash,
4659 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4662 if encoding_type == 0 {
4663 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4664 let encoded_value = query_short_channel_ids.encode();
4665 assert_eq!(encoded_value, target_value);
4667 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4668 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4669 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4670 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4671 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4673 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4674 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4675 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4680 fn encoding_reply_short_channel_ids_end() {
4681 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4682 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4683 chain_hash: expected_chain_hash,
4684 full_information: true,
4686 let encoded_value = reply_short_channel_ids_end.encode();
4687 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4688 assert_eq!(encoded_value, target_value);
4690 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4691 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4692 assert_eq!(reply_short_channel_ids_end.full_information, true);
4696 fn encoding_gossip_timestamp_filter(){
4697 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4698 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4699 chain_hash: expected_chain_hash,
4700 first_timestamp: 1590000000,
4701 timestamp_range: 0xffff_ffff,
4703 let encoded_value = gossip_timestamp_filter.encode();
4704 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4705 assert_eq!(encoded_value, target_value);
4707 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4708 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4709 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4710 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4714 fn decode_onion_hop_data_len_as_bigsize() {
4715 // Tests that we can decode an onion payload that is >253 bytes.
4716 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4717 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4720 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4721 // payload length to be encoded over multiple bytes rather than a single u8.
4722 let big_payload = encode_big_payload().unwrap();
4723 let mut rd = Cursor::new(&big_payload[..]);
4725 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4726 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4727 ::read(&mut rd, (None, &&node_signer)).unwrap();
4729 // see above test, needs to be a separate method for use of the serialization macros.
4730 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4731 use crate::util::ser::HighZeroBytesDroppedBigSize;
4732 let payload = msgs::OutboundOnionPayload::Forward {
4733 short_channel_id: 0xdeadbeef1bad1dea,
4734 amt_to_forward: 1000,
4735 outgoing_cltv_value: 0xffffffff,
4737 let mut encoded_payload = Vec::new();
4738 let test_bytes = vec![42u8; 1000];
4739 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4740 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4741 (1, test_bytes, required_vec),
4742 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4743 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4744 (6, short_channel_id, required)
4751 #[cfg(feature = "std")]
4752 fn test_socket_address_from_str() {
4753 let tcpip_v4 = SocketAddress::TcpIpV4 {
4754 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4757 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4758 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4760 let tcpip_v6 = SocketAddress::TcpIpV6 {
4761 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4764 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4765 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4767 let hostname = SocketAddress::Hostname {
4768 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4771 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4772 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4774 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4775 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4776 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4778 let onion_v3 = SocketAddress::OnionV3 {
4779 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4780 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4785 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4786 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4788 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4789 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4790 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4791 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4792 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4793 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4794 assert!("localhost".parse::<SocketAddress>().is_err());
4795 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4796 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4797 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4798 assert!("invalid-address".parse::<SocketAddress>().is_err());
4799 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4803 #[cfg(feature = "std")]
4804 fn test_socket_address_to_socket_addrs() {
4805 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4806 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4807 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4808 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4809 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4810 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4811 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4812 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4813 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4817 port: 1234 }.to_socket_addrs().is_err());