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::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret};
36 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
37 use crate::ln::onion_utils;
38 use crate::onion_message;
39 use crate::sign::{NodeSigner, Recipient};
41 use crate::prelude::*;
42 #[cfg(feature = "std")]
43 use core::convert::TryFrom;
47 #[cfg(feature = "std")]
48 use core::str::FromStr;
49 #[cfg(feature = "std")]
50 use std::net::SocketAddr;
51 use core::fmt::Display;
52 use crate::io::{self, Cursor, Read};
53 use crate::io_extras::read_to_end;
55 use crate::events::{EventsProvider, MessageSendEventsProvider};
56 use crate::crypto::streams::ChaChaPolyReadAdapter;
57 use crate::util::logger;
58 use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
59 use crate::util::base32;
61 use crate::routing::gossip::{NodeAlias, NodeId};
63 /// 21 million * 10^8 * 1000
64 pub(crate) const MAX_VALUE_MSAT: u64 = 21_000_000_0000_0000_000;
67 /// A partial signature that also contains the Musig2 nonce its signer used
68 #[derive(Clone, Debug, 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>,
548 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
551 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
552 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
553 pub struct TxInitRbf {
555 pub channel_id: ChannelId,
556 /// The locktime of the transaction
558 /// The feerate of the transaction
559 pub feerate_sat_per_1000_weight: u32,
560 /// The number of satoshis the sender will contribute to or, if negative, remove from
561 /// (e.g. splice-out) the funding output of the transaction
562 pub funding_output_contribution: Option<i64>,
565 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
568 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
569 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
570 pub struct TxAckRbf {
572 pub channel_id: ChannelId,
573 /// The number of satoshis the sender will contribute to or, if negative, remove from
574 /// (e.g. splice-out) the funding output of the transaction
575 pub funding_output_contribution: Option<i64>,
578 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
580 // TODO(dual_funding): Add spec link for `tx_abort`.
581 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
584 pub channel_id: ChannelId,
589 /// A [`shutdown`] message to be sent to or received from a peer.
591 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
592 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
593 pub struct Shutdown {
595 pub channel_id: ChannelId,
596 /// The destination of this peer's funds on closing.
598 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
599 pub scriptpubkey: ScriptBuf,
602 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
604 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
606 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
607 pub struct ClosingSignedFeeRange {
608 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
610 pub min_fee_satoshis: u64,
611 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
613 pub max_fee_satoshis: u64,
616 /// A [`closing_signed`] message to be sent to or received from a peer.
618 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
619 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
620 pub struct ClosingSigned {
622 pub channel_id: ChannelId,
623 /// The proposed total fee for the closing transaction
624 pub fee_satoshis: u64,
625 /// A signature on the closing transaction
626 pub signature: Signature,
627 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
629 pub fee_range: Option<ClosingSignedFeeRange>,
632 /// An [`update_add_htlc`] message to be sent to or received from a peer.
634 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
635 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
636 pub struct UpdateAddHTLC {
638 pub channel_id: ChannelId,
641 /// The HTLC value in milli-satoshi
642 pub amount_msat: u64,
643 /// The payment hash, the pre-image of which controls HTLC redemption
644 pub payment_hash: PaymentHash,
645 /// The expiry height of the HTLC
646 pub cltv_expiry: u32,
647 /// The extra fee skimmed by the sender of this message. See
648 /// [`ChannelConfig::accept_underpaying_htlcs`].
650 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
651 pub skimmed_fee_msat: Option<u64>,
652 /// The onion routing packet with encrypted data for the next hop.
653 pub onion_routing_packet: OnionPacket,
654 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
655 /// routing packet and the recipient-provided encrypted payload within.
656 pub blinding_point: Option<PublicKey>,
659 /// An onion message to be sent to or received from a peer.
661 // TODO: update with link to OM when they are merged into the BOLTs
662 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
663 pub struct OnionMessage {
664 /// Used in decrypting the onion packet's payload.
665 pub blinding_point: PublicKey,
666 /// The full onion packet including hop data, pubkey, and hmac
667 pub onion_routing_packet: onion_message::packet::Packet,
670 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
672 /// [`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
673 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
674 pub struct UpdateFulfillHTLC {
676 pub channel_id: ChannelId,
679 /// The pre-image of the payment hash, allowing HTLC redemption
680 pub payment_preimage: PaymentPreimage,
683 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
685 /// [`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
686 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
687 pub struct UpdateFailHTLC {
689 pub channel_id: ChannelId,
692 pub(crate) reason: OnionErrorPacket,
695 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
697 /// [`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
698 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
699 pub struct UpdateFailMalformedHTLC {
701 pub channel_id: ChannelId,
704 pub(crate) sha256_of_onion: [u8; 32],
706 pub failure_code: u16,
709 /// A [`commitment_signed`] message to be sent to or received from a peer.
711 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
712 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
713 pub struct CommitmentSigned {
715 pub channel_id: ChannelId,
716 /// A signature on the commitment transaction
717 pub signature: Signature,
718 /// Signatures on the HTLC transactions
719 pub htlc_signatures: Vec<Signature>,
721 /// The partial Taproot signature on the commitment transaction
722 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
725 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
727 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
728 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
729 pub struct RevokeAndACK {
731 pub channel_id: ChannelId,
732 /// The secret corresponding to the per-commitment point
733 pub per_commitment_secret: [u8; 32],
734 /// The next sender-broadcast commitment transaction's per-commitment point
735 pub next_per_commitment_point: PublicKey,
737 /// Musig nonce the recipient should use in their next commitment signature message
738 pub next_local_nonce: Option<musig2::types::PublicNonce>
741 /// An [`update_fee`] message to be sent to or received from a peer
743 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
744 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
745 pub struct UpdateFee {
747 pub channel_id: ChannelId,
748 /// Fee rate per 1000-weight of the transaction
749 pub feerate_per_kw: u32,
752 /// A [`channel_reestablish`] message to be sent to or received from a peer.
754 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
755 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
756 pub struct ChannelReestablish {
758 pub channel_id: ChannelId,
759 /// The next commitment number for the sender
760 pub next_local_commitment_number: u64,
761 /// The next commitment number for the recipient
762 pub next_remote_commitment_number: u64,
763 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
764 /// belonging to the recipient
765 pub your_last_per_commitment_secret: [u8; 32],
766 /// The sender's per-commitment point for their current commitment transaction
767 pub my_current_per_commitment_point: PublicKey,
768 /// The next funding transaction ID
769 pub next_funding_txid: Option<Txid>,
772 /// An [`announcement_signatures`] message to be sent to or received from a peer.
774 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
775 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
776 pub struct AnnouncementSignatures {
778 pub channel_id: ChannelId,
779 /// The short channel ID
780 pub short_channel_id: u64,
781 /// A signature by the node key
782 pub node_signature: Signature,
783 /// A signature by the funding key
784 pub bitcoin_signature: Signature,
787 /// An address which can be used to connect to a remote peer.
788 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
789 pub enum SocketAddress {
790 /// An IPv4 address and port on which the peer is listening.
792 /// The 4-byte IPv4 address
794 /// The port on which the node is listening
797 /// An IPv6 address and port on which the peer is listening.
799 /// The 16-byte IPv6 address
801 /// The port on which the node is listening
804 /// An old-style Tor onion address/port on which the peer is listening.
806 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
807 /// addresses. Thus, the details are not parsed here.
809 /// A new-style Tor onion address/port on which the peer is listening.
811 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
812 /// wrap as base32 and append ".onion".
814 /// The ed25519 long-term public key of the peer
815 ed25519_pubkey: [u8; 32],
816 /// The checksum of the pubkey and version, as included in the onion address
818 /// The version byte, as defined by the Tor Onion v3 spec.
820 /// The port on which the node is listening
823 /// A hostname/port on which the peer is listening.
825 /// The hostname on which the node is listening.
827 /// The port on which the node is listening.
832 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
834 pub(crate) fn get_id(&self) -> u8 {
836 &SocketAddress::TcpIpV4 {..} => { 1 },
837 &SocketAddress::TcpIpV6 {..} => { 2 },
838 &SocketAddress::OnionV2(_) => { 3 },
839 &SocketAddress::OnionV3 {..} => { 4 },
840 &SocketAddress::Hostname {..} => { 5 },
844 /// Strict byte-length of address descriptor, 1-byte type not recorded
845 fn len(&self) -> u16 {
847 &SocketAddress::TcpIpV4 { .. } => { 6 },
848 &SocketAddress::TcpIpV6 { .. } => { 18 },
849 &SocketAddress::OnionV2(_) => { 12 },
850 &SocketAddress::OnionV3 { .. } => { 37 },
851 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
852 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
856 /// The maximum length of any address descriptor, not including the 1-byte type.
857 /// This maximum length is reached by a hostname address descriptor:
858 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
859 pub(crate) const MAX_LEN: u16 = 258;
861 pub(crate) fn is_tor(&self) -> bool {
863 &SocketAddress::TcpIpV4 {..} => false,
864 &SocketAddress::TcpIpV6 {..} => false,
865 &SocketAddress::OnionV2(_) => true,
866 &SocketAddress::OnionV3 {..} => true,
867 &SocketAddress::Hostname {..} => false,
872 impl Writeable for SocketAddress {
873 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
875 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
880 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
885 &SocketAddress::OnionV2(bytes) => {
887 bytes.write(writer)?;
889 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
891 ed25519_pubkey.write(writer)?;
892 checksum.write(writer)?;
893 version.write(writer)?;
896 &SocketAddress::Hostname { ref hostname, ref port } => {
898 hostname.write(writer)?;
906 impl Readable for Result<SocketAddress, u8> {
907 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
908 let byte = <u8 as Readable>::read(reader)?;
911 Ok(Ok(SocketAddress::TcpIpV4 {
912 addr: Readable::read(reader)?,
913 port: Readable::read(reader)?,
917 Ok(Ok(SocketAddress::TcpIpV6 {
918 addr: Readable::read(reader)?,
919 port: Readable::read(reader)?,
922 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
924 Ok(Ok(SocketAddress::OnionV3 {
925 ed25519_pubkey: Readable::read(reader)?,
926 checksum: Readable::read(reader)?,
927 version: Readable::read(reader)?,
928 port: Readable::read(reader)?,
932 Ok(Ok(SocketAddress::Hostname {
933 hostname: Readable::read(reader)?,
934 port: Readable::read(reader)?,
937 _ => return Ok(Err(byte)),
942 impl Readable for SocketAddress {
943 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
944 match Readable::read(reader) {
945 Ok(Ok(res)) => Ok(res),
946 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
952 /// [`SocketAddress`] error variants
953 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
954 pub enum SocketAddressParseError {
955 /// Socket address (IPv4/IPv6) parsing error
957 /// Invalid input format
961 /// Invalid onion v3 address
965 impl fmt::Display for SocketAddressParseError {
966 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
968 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
969 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
970 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
971 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
972 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
977 #[cfg(feature = "std")]
978 impl From<std::net::SocketAddrV4> for SocketAddress {
979 fn from(addr: std::net::SocketAddrV4) -> Self {
980 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
984 #[cfg(feature = "std")]
985 impl From<std::net::SocketAddrV6> for SocketAddress {
986 fn from(addr: std::net::SocketAddrV6) -> Self {
987 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
991 #[cfg(feature = "std")]
992 impl From<std::net::SocketAddr> for SocketAddress {
993 fn from(addr: std::net::SocketAddr) -> Self {
995 std::net::SocketAddr::V4(addr) => addr.into(),
996 std::net::SocketAddr::V6(addr) => addr.into(),
1001 #[cfg(feature = "std")]
1002 impl std::net::ToSocketAddrs for SocketAddress {
1003 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
1005 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
1007 SocketAddress::TcpIpV4 { addr, port } => {
1008 let ip_addr = std::net::Ipv4Addr::from(*addr);
1009 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1010 Ok(vec![socket_addr].into_iter())
1012 SocketAddress::TcpIpV6 { addr, port } => {
1013 let ip_addr = std::net::Ipv6Addr::from(*addr);
1014 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1015 Ok(vec![socket_addr].into_iter())
1017 SocketAddress::Hostname { ref hostname, port } => {
1018 (hostname.as_str(), *port).to_socket_addrs()
1020 SocketAddress::OnionV2(..) => {
1021 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1022 addresses is currently unsupported."))
1024 SocketAddress::OnionV3 { .. } => {
1025 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1026 addresses is currently unsupported."))
1032 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1034 /// The host part must end with ".onion".
1035 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1036 if host.ends_with(".onion") {
1037 let domain = &host[..host.len() - ".onion".len()];
1038 if domain.len() != 56 {
1039 return Err(SocketAddressParseError::InvalidOnionV3);
1041 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1042 if onion.len() != 35 {
1043 return Err(SocketAddressParseError::InvalidOnionV3);
1045 let version = onion[0];
1046 let first_checksum_flag = onion[1];
1047 let second_checksum_flag = onion[2];
1048 let mut ed25519_pubkey = [0; 32];
1049 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1050 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1051 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1054 return Err(SocketAddressParseError::InvalidInput);
1058 impl Display for SocketAddress {
1059 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1061 SocketAddress::TcpIpV4{addr, port} => write!(
1062 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1063 SocketAddress::TcpIpV6{addr, port} => write!(
1065 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1066 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
1068 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1069 SocketAddress::OnionV3 {
1075 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1076 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1077 addr.extend_from_slice(ed25519_pubkey);
1078 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1079 write!(f, "{}.onion:{}", onion, port)?
1081 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1087 #[cfg(feature = "std")]
1088 impl FromStr for SocketAddress {
1089 type Err = SocketAddressParseError;
1091 fn from_str(s: &str) -> Result<Self, Self::Err> {
1092 match std::net::SocketAddr::from_str(s) {
1093 Ok(addr) => Ok(addr.into()),
1095 let trimmed_input = match s.rfind(":") {
1097 None => return Err(SocketAddressParseError::InvalidInput),
1099 let host = &s[..trimmed_input];
1100 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1101 if host.ends_with(".onion") {
1102 return parse_onion_address(host, port);
1104 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1105 return Ok(SocketAddress::Hostname { hostname, port });
1107 return Err(SocketAddressParseError::SocketAddrParse)
1113 /// Represents the set of gossip messages that require a signature from a node's identity key.
1114 pub enum UnsignedGossipMessage<'a> {
1115 /// An unsigned channel announcement.
1116 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1117 /// An unsigned channel update.
1118 ChannelUpdate(&'a UnsignedChannelUpdate),
1119 /// An unsigned node announcement.
1120 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1123 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1124 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1126 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1127 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1128 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1133 /// The unsigned part of a [`node_announcement`] message.
1135 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1136 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1137 pub struct UnsignedNodeAnnouncement {
1138 /// The advertised features
1139 pub features: NodeFeatures,
1140 /// A strictly monotonic announcement counter, with gaps allowed
1142 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1144 pub node_id: NodeId,
1145 /// An RGB color for UI purposes
1147 /// An alias, for UI purposes.
1149 /// This should be sanitized before use. There is no guarantee of uniqueness.
1150 pub alias: NodeAlias,
1151 /// List of addresses on which this node is reachable
1152 pub addresses: Vec<SocketAddress>,
1153 /// Excess address data which was signed as a part of the message which we do not (yet) understand how
1156 /// This is stored to ensure forward-compatibility as new address types are added to the lightning gossip protocol.
1157 pub excess_address_data: Vec<u8>,
1158 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1161 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1162 pub excess_data: Vec<u8>,
1164 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1165 /// A [`node_announcement`] message to be sent to or received from a peer.
1167 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1168 pub struct NodeAnnouncement {
1169 /// The signature by the node key
1170 pub signature: Signature,
1171 /// The actual content of the announcement
1172 pub contents: UnsignedNodeAnnouncement,
1175 /// The unsigned part of a [`channel_announcement`] message.
1177 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1178 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1179 pub struct UnsignedChannelAnnouncement {
1180 /// The advertised channel features
1181 pub features: ChannelFeatures,
1182 /// The genesis hash of the blockchain where the channel is to be opened
1183 pub chain_hash: ChainHash,
1184 /// The short channel ID
1185 pub short_channel_id: u64,
1186 /// One of the two `node_id`s which are endpoints of this channel
1187 pub node_id_1: NodeId,
1188 /// The other of the two `node_id`s which are endpoints of this channel
1189 pub node_id_2: NodeId,
1190 /// The funding key for the first node
1191 pub bitcoin_key_1: NodeId,
1192 /// The funding key for the second node
1193 pub bitcoin_key_2: NodeId,
1194 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1197 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1198 pub excess_data: Vec<u8>,
1200 /// A [`channel_announcement`] message to be sent to or received from a peer.
1202 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1203 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1204 pub struct ChannelAnnouncement {
1205 /// Authentication of the announcement by the first public node
1206 pub node_signature_1: Signature,
1207 /// Authentication of the announcement by the second public node
1208 pub node_signature_2: Signature,
1209 /// Proof of funding UTXO ownership by the first public node
1210 pub bitcoin_signature_1: Signature,
1211 /// Proof of funding UTXO ownership by the second public node
1212 pub bitcoin_signature_2: Signature,
1213 /// The actual announcement
1214 pub contents: UnsignedChannelAnnouncement,
1217 /// The unsigned part of a [`channel_update`] message.
1219 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1220 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1221 pub struct UnsignedChannelUpdate {
1222 /// The genesis hash of the blockchain where the channel is to be opened
1223 pub chain_hash: ChainHash,
1224 /// The short channel ID
1225 pub short_channel_id: u64,
1226 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1230 /// The number of blocks such that if:
1231 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1232 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1233 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1234 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1235 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1236 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1237 /// constructing the route.
1238 pub cltv_expiry_delta: u16,
1239 /// The minimum HTLC size incoming to sender, in milli-satoshi
1240 pub htlc_minimum_msat: u64,
1241 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1243 /// This used to be optional.
1244 pub htlc_maximum_msat: u64,
1245 /// The base HTLC fee charged by sender, in milli-satoshi
1246 pub fee_base_msat: u32,
1247 /// The amount to fee multiplier, in micro-satoshi
1248 pub fee_proportional_millionths: u32,
1249 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1252 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1253 pub excess_data: Vec<u8>,
1255 /// A [`channel_update`] message to be sent to or received from a peer.
1257 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1258 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1259 pub struct ChannelUpdate {
1260 /// A signature of the channel update
1261 pub signature: Signature,
1262 /// The actual channel update
1263 pub contents: UnsignedChannelUpdate,
1266 /// A [`query_channel_range`] message is used to query a peer for channel
1267 /// UTXOs in a range of blocks. The recipient of a query makes a best
1268 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1271 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1272 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1273 pub struct QueryChannelRange {
1274 /// The genesis hash of the blockchain being queried
1275 pub chain_hash: ChainHash,
1276 /// The height of the first block for the channel UTXOs being queried
1277 pub first_blocknum: u32,
1278 /// The number of blocks to include in the query results
1279 pub number_of_blocks: u32,
1282 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1285 /// Multiple `reply_channel_range` messages can be sent in reply
1286 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1287 /// best effort to respond based on their local network view which may
1288 /// not be a perfect view of the network. The `short_channel_id`s in the
1289 /// reply are encoded. We only support `encoding_type=0` uncompressed
1290 /// serialization and do not support `encoding_type=1` zlib serialization.
1292 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1293 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1294 pub struct ReplyChannelRange {
1295 /// The genesis hash of the blockchain being queried
1296 pub chain_hash: ChainHash,
1297 /// The height of the first block in the range of the reply
1298 pub first_blocknum: u32,
1299 /// The number of blocks included in the range of the reply
1300 pub number_of_blocks: u32,
1301 /// True when this is the final reply for a query
1302 pub sync_complete: bool,
1303 /// The `short_channel_id`s in the channel range
1304 pub short_channel_ids: Vec<u64>,
1307 /// A [`query_short_channel_ids`] message is used to query a peer for
1308 /// routing gossip messages related to one or more `short_channel_id`s.
1310 /// The query recipient will reply with the latest, if available,
1311 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1312 /// it maintains for the requested `short_channel_id`s followed by a
1313 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1314 /// this query are encoded. We only support `encoding_type=0` uncompressed
1315 /// serialization and do not support `encoding_type=1` zlib serialization.
1317 /// [`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
1318 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1319 pub struct QueryShortChannelIds {
1320 /// The genesis hash of the blockchain being queried
1321 pub chain_hash: ChainHash,
1322 /// The short_channel_ids that are being queried
1323 pub short_channel_ids: Vec<u64>,
1326 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1327 /// message. The query recipient makes a best
1328 /// effort to respond based on their local network view which may not be
1329 /// a perfect view of the network.
1331 /// [`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
1332 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1333 pub struct ReplyShortChannelIdsEnd {
1334 /// The genesis hash of the blockchain that was queried
1335 pub chain_hash: ChainHash,
1336 /// Indicates if the query recipient maintains up-to-date channel
1337 /// information for the `chain_hash`
1338 pub full_information: bool,
1341 /// A [`gossip_timestamp_filter`] message is used by a node to request
1342 /// gossip relay for messages in the requested time range when the
1343 /// `gossip_queries` feature has been negotiated.
1345 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1346 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1347 pub struct GossipTimestampFilter {
1348 /// The genesis hash of the blockchain for channel and node information
1349 pub chain_hash: ChainHash,
1350 /// The starting unix timestamp
1351 pub first_timestamp: u32,
1352 /// The range of information in seconds
1353 pub timestamp_range: u32,
1356 /// Encoding type for data compression of collections in gossip queries.
1358 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1359 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1361 Uncompressed = 0x00,
1364 /// Used to put an error message in a [`LightningError`].
1365 #[derive(Clone, Debug, Hash, PartialEq)]
1366 pub enum ErrorAction {
1367 /// The peer took some action which made us think they were useless. Disconnect them.
1369 /// An error message which we should make an effort to send before we disconnect.
1370 msg: Option<ErrorMessage>
1372 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1373 DisconnectPeerWithWarning {
1374 /// A warning message which we should make an effort to send before we disconnect.
1375 msg: WarningMessage,
1377 /// The peer did something harmless that we weren't able to process, just log and ignore
1378 // New code should *not* use this. New code must use IgnoreAndLog, below!
1380 /// The peer did something harmless that we weren't able to meaningfully process.
1381 /// If the error is logged, log it at the given level.
1382 IgnoreAndLog(logger::Level),
1383 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1384 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1385 /// our own channel announcements.
1386 IgnoreDuplicateGossip,
1387 /// The peer did something incorrect. Tell them.
1389 /// The message to send.
1392 /// The peer did something incorrect. Tell them without closing any channels.
1393 SendWarningMessage {
1394 /// The message to send.
1395 msg: WarningMessage,
1396 /// The peer may have done something harmless that we weren't able to meaningfully process,
1397 /// though we should still tell them about it.
1398 /// If this event is logged, log it at the given level.
1399 log_level: logger::Level,
1403 /// An Err type for failure to process messages.
1404 #[derive(Clone, Debug)]
1405 pub struct LightningError {
1406 /// A human-readable message describing the error
1408 /// The action which should be taken against the offending peer.
1409 pub action: ErrorAction,
1412 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1413 /// transaction updates if they were pending.
1414 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1415 pub struct CommitmentUpdate {
1416 /// `update_add_htlc` messages which should be sent
1417 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1418 /// `update_fulfill_htlc` messages which should be sent
1419 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1420 /// `update_fail_htlc` messages which should be sent
1421 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1422 /// `update_fail_malformed_htlc` messages which should be sent
1423 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1424 /// An `update_fee` message which should be sent
1425 pub update_fee: Option<UpdateFee>,
1426 /// A `commitment_signed` message which should be sent
1427 pub commitment_signed: CommitmentSigned,
1430 /// A trait to describe an object which can receive channel messages.
1432 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1433 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1434 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1436 /// Handle an incoming `open_channel` message from the given peer.
1437 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1438 /// Handle an incoming `open_channel2` message from the given peer.
1439 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1440 /// Handle an incoming `accept_channel` message from the given peer.
1441 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1442 /// Handle an incoming `accept_channel2` message from the given peer.
1443 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1444 /// Handle an incoming `funding_created` message from the given peer.
1445 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1446 /// Handle an incoming `funding_signed` message from the given peer.
1447 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1448 /// Handle an incoming `channel_ready` message from the given peer.
1449 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1452 /// Handle an incoming `shutdown` message from the given peer.
1453 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1454 /// Handle an incoming `closing_signed` message from the given peer.
1455 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1458 /// Handle an incoming `stfu` message from the given peer.
1459 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1462 /// Handle an incoming `splice` message from the given peer.
1463 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1464 /// Handle an incoming `splice_ack` message from the given peer.
1465 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1466 /// Handle an incoming `splice_locked` message from the given peer.
1467 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1469 // Interactive channel construction
1470 /// Handle an incoming `tx_add_input message` from the given peer.
1471 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1472 /// Handle an incoming `tx_add_output` message from the given peer.
1473 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1474 /// Handle an incoming `tx_remove_input` message from the given peer.
1475 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1476 /// Handle an incoming `tx_remove_output` message from the given peer.
1477 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1478 /// Handle an incoming `tx_complete message` from the given peer.
1479 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1480 /// Handle an incoming `tx_signatures` message from the given peer.
1481 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1482 /// Handle an incoming `tx_init_rbf` message from the given peer.
1483 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1484 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1485 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1486 /// Handle an incoming `tx_abort message` from the given peer.
1487 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1490 /// Handle an incoming `update_add_htlc` message from the given peer.
1491 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1492 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1493 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1494 /// Handle an incoming `update_fail_htlc` message from the given peer.
1495 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1496 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1497 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1498 /// Handle an incoming `commitment_signed` message from the given peer.
1499 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1500 /// Handle an incoming `revoke_and_ack` message from the given peer.
1501 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1503 /// Handle an incoming `update_fee` message from the given peer.
1504 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1506 // Channel-to-announce:
1507 /// Handle an incoming `announcement_signatures` message from the given peer.
1508 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1510 // Connection loss/reestablish:
1511 /// Indicates a connection to the peer failed/an existing connection was lost.
1512 fn peer_disconnected(&self, their_node_id: &PublicKey);
1514 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1516 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1517 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1518 /// message handlers may still wish to communicate with this peer.
1519 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1520 /// Handle an incoming `channel_reestablish` message from the given peer.
1521 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1523 /// Handle an incoming `channel_update` message from the given peer.
1524 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1527 /// Handle an incoming `error` message from the given peer.
1528 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1530 // Handler information:
1531 /// Gets the node feature flags which this handler itself supports. All available handlers are
1532 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1533 /// which are broadcasted in our [`NodeAnnouncement`] message.
1534 fn provided_node_features(&self) -> NodeFeatures;
1536 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1537 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1538 /// which are sent in our [`Init`] message.
1540 /// Note that this method is called before [`Self::peer_connected`].
1541 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1543 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1545 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1546 /// connecting to peers.
1547 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1550 /// A trait to describe an object which can receive routing messages.
1552 /// # Implementor DoS Warnings
1554 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1555 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1556 /// repeated disk I/O for queries accessing different parts of the network graph.
1557 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1558 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1559 /// `false` or returning an `Err` otherwise.
1560 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1561 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1562 /// or returning an `Err` otherwise.
1563 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1564 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1565 /// `false` or returning an `Err` otherwise.
1566 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1567 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1568 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1569 /// for a single channel.
1570 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1571 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1572 /// the node *after* the provided pubkey and including up to one announcement immediately
1573 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1574 /// If `None` is provided for `starting_point`, we start at the first node.
1575 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1576 /// Called when a connection is established with a peer. This can be used to
1577 /// perform routing table synchronization using a strategy defined by the
1580 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1581 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1582 /// message handlers may still wish to communicate with this peer.
1583 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1584 /// Handles the reply of a query we initiated to learn about channels
1585 /// for a given range of blocks. We can expect to receive one or more
1586 /// replies to a single query.
1587 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1588 /// Handles the reply of a query we initiated asking for routing gossip
1589 /// messages for a list of channels. We should receive this message when
1590 /// a node has completed its best effort to send us the pertaining routing
1591 /// gossip messages.
1592 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1593 /// Handles when a peer asks us to send a list of `short_channel_id`s
1594 /// for the requested range of blocks.
1595 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1596 /// Handles when a peer asks us to send routing gossip messages for a
1597 /// list of `short_channel_id`s.
1598 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1600 // Handler queueing status:
1601 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1602 /// pending some async action. While there is no guarantee of the rate of future messages, the
1603 /// caller should seek to reduce the rate of new gossip messages handled, especially
1604 /// [`ChannelAnnouncement`]s.
1605 fn processing_queue_high(&self) -> bool;
1607 // Handler information:
1608 /// Gets the node feature flags which this handler itself supports. All available handlers are
1609 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1610 /// which are broadcasted in our [`NodeAnnouncement`] message.
1611 fn provided_node_features(&self) -> NodeFeatures;
1612 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1613 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1614 /// which are sent in our [`Init`] message.
1616 /// Note that this method is called before [`Self::peer_connected`].
1617 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1620 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1621 pub trait OnionMessageHandler: EventsProvider {
1622 /// Handle an incoming `onion_message` message from the given peer.
1623 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1625 /// Returns the next pending onion message for the peer with the given node id.
1626 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1628 /// Called when a connection is established with a peer. Can be used to track which peers
1629 /// advertise onion message support and are online.
1631 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1632 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1633 /// message handlers may still wish to communicate with this peer.
1634 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1636 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1637 /// drop and refuse to forward onion messages to this peer.
1638 fn peer_disconnected(&self, their_node_id: &PublicKey);
1640 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1641 /// to drop any buffered onion messages intended for prospective peers.
1642 fn timer_tick_occurred(&self);
1644 // Handler information:
1645 /// Gets the node feature flags which this handler itself supports. All available handlers are
1646 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1647 /// which are broadcasted in our [`NodeAnnouncement`] message.
1648 fn provided_node_features(&self) -> NodeFeatures;
1650 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1651 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1652 /// which are sent in our [`Init`] message.
1654 /// Note that this method is called before [`Self::peer_connected`].
1655 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1659 #[cfg_attr(test, derive(Debug, PartialEq))]
1660 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1661 /// the payment is associated with an invoice.
1662 pub struct FinalOnionHopData {
1663 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1664 /// Because it is generated by the recipient and included in the invoice, it also provides
1665 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1666 pub payment_secret: PaymentSecret,
1667 /// The intended total amount that this payment is for.
1669 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1670 pub total_msat: u64,
1673 mod fuzzy_internal_msgs {
1674 use bitcoin::secp256k1::PublicKey;
1675 use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1676 use crate::prelude::*;
1677 use crate::ln::{PaymentPreimage, PaymentSecret};
1678 use crate::ln::features::BlindedHopFeatures;
1679 use super::{FinalOnionHopData, TrampolineOnionPacket};
1681 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1682 // them from untrusted input):
1684 pub enum InboundOnionPayload {
1686 short_channel_id: u64,
1687 /// The value, in msat, of the payment after this hop's fee is deducted.
1688 amt_to_forward: u64,
1689 outgoing_cltv_value: u32,
1692 payment_data: Option<FinalOnionHopData>,
1693 payment_metadata: Option<Vec<u8>>,
1694 keysend_preimage: Option<PaymentPreimage>,
1695 custom_tlvs: Vec<(u64, Vec<u8>)>,
1696 sender_intended_htlc_amt_msat: u64,
1697 cltv_expiry_height: u32,
1700 short_channel_id: u64,
1701 payment_relay: PaymentRelay,
1702 payment_constraints: PaymentConstraints,
1703 features: BlindedHopFeatures,
1704 intro_node_blinding_point: Option<PublicKey>,
1707 sender_intended_htlc_amt_msat: u64,
1709 cltv_expiry_height: u32,
1710 payment_secret: PaymentSecret,
1711 payment_constraints: PaymentConstraints,
1712 intro_node_blinding_point: Option<PublicKey>,
1713 keysend_preimage: Option<PaymentPreimage>,
1717 pub(crate) enum OutboundOnionPayload {
1719 short_channel_id: u64,
1720 /// The value, in msat, of the payment after this hop's fee is deducted.
1721 amt_to_forward: u64,
1722 outgoing_cltv_value: u32,
1725 TrampolineEntrypoint {
1726 amt_to_forward: u64,
1727 outgoing_cltv_value: u32,
1728 multipath_trampoline_data: Option<FinalOnionHopData>,
1729 trampoline_packet: TrampolineOnionPacket,
1732 payment_data: Option<FinalOnionHopData>,
1733 payment_metadata: Option<Vec<u8>>,
1734 keysend_preimage: Option<PaymentPreimage>,
1735 custom_tlvs: Vec<(u64, Vec<u8>)>,
1736 sender_intended_htlc_amt_msat: u64,
1737 cltv_expiry_height: u32,
1740 encrypted_tlvs: Vec<u8>,
1741 intro_node_blinding_point: Option<PublicKey>,
1744 sender_intended_htlc_amt_msat: u64,
1746 cltv_expiry_height: u32,
1747 encrypted_tlvs: Vec<u8>,
1748 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1749 keysend_preimage: Option<PaymentPreimage>,
1753 pub(crate) enum OutboundTrampolinePayload {
1756 /// The value, in msat, of the payment after this hop's fee is deducted.
1757 amt_to_forward: u64,
1758 outgoing_cltv_value: u32,
1759 /// The node id to which the trampoline node must find a route
1760 outgoing_node_id: PublicKey,
1764 pub struct DecodedOnionErrorPacket {
1765 pub(crate) hmac: [u8; 32],
1766 pub(crate) failuremsg: Vec<u8>,
1767 pub(crate) pad: Vec<u8>,
1771 pub use self::fuzzy_internal_msgs::*;
1772 #[cfg(not(fuzzing))]
1773 pub(crate) use self::fuzzy_internal_msgs::*;
1775 /// BOLT 4 onion packet including hop data for the next peer.
1776 #[derive(Clone, Hash, PartialEq, Eq)]
1777 pub struct OnionPacket {
1778 /// BOLT 4 version number.
1780 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1781 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1782 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1783 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1785 pub public_key: Result<PublicKey, secp256k1::Error>,
1786 /// 1300 bytes encrypted payload for the next hop.
1787 pub hop_data: [u8; 20*65],
1788 /// HMAC to verify the integrity of hop_data.
1792 impl onion_utils::Packet for OnionPacket {
1793 type Data = onion_utils::FixedSizeOnionPacket;
1794 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1797 public_key: Ok(pubkey),
1798 hop_data: hop_data.0,
1804 impl fmt::Debug for OnionPacket {
1805 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1806 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1810 /// BOLT 4 onion packet including hop data for the next peer.
1811 #[derive(Clone, Hash, PartialEq, Eq)]
1812 pub struct TrampolineOnionPacket {
1813 /// Bolt 04 version number
1815 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1816 pub public_key: PublicKey,
1817 /// Encrypted payload for the next hop
1819 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1820 // 1300 bytes. The expected default is 650 bytes.
1821 // TODO: if 650 ends up being the most common size, optimize this to be:
1822 // enum { SixFifty([u8; 650]), VarLen(Vec<u8>) }
1823 pub hop_data: Vec<u8>,
1824 /// HMAC to verify the integrity of hop_data
1828 impl onion_utils::Packet for TrampolineOnionPacket {
1829 type Data = Vec<u8>;
1830 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1840 impl Writeable for TrampolineOnionPacket {
1841 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1842 self.version.write(w)?;
1843 self.public_key.write(w)?;
1844 w.write_all(&self.hop_data)?;
1845 self.hmac.write(w)?;
1850 impl Debug for TrampolineOnionPacket {
1851 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1852 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1856 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1857 pub(crate) struct OnionErrorPacket {
1858 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1859 // (TODO) We limit it in decode to much lower...
1860 pub(crate) data: Vec<u8>,
1863 impl fmt::Display for DecodeError {
1864 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1866 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1867 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1868 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1869 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1870 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1871 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1872 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1873 DecodeError::DangerousValue => f.write_str("Value would be dangerous to continue execution with"),
1878 impl From<io::Error> for DecodeError {
1879 fn from(e: io::Error) -> Self {
1880 if e.kind() == io::ErrorKind::UnexpectedEof {
1881 DecodeError::ShortRead
1883 DecodeError::Io(e.kind())
1888 impl Writeable for AcceptChannel {
1889 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1890 self.common_fields.temporary_channel_id.write(w)?;
1891 self.common_fields.dust_limit_satoshis.write(w)?;
1892 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1893 self.channel_reserve_satoshis.write(w)?;
1894 self.common_fields.htlc_minimum_msat.write(w)?;
1895 self.common_fields.minimum_depth.write(w)?;
1896 self.common_fields.to_self_delay.write(w)?;
1897 self.common_fields.max_accepted_htlcs.write(w)?;
1898 self.common_fields.funding_pubkey.write(w)?;
1899 self.common_fields.revocation_basepoint.write(w)?;
1900 self.common_fields.payment_basepoint.write(w)?;
1901 self.common_fields.delayed_payment_basepoint.write(w)?;
1902 self.common_fields.htlc_basepoint.write(w)?;
1903 self.common_fields.first_per_commitment_point.write(w)?;
1904 #[cfg(not(taproot))]
1905 encode_tlv_stream!(w, {
1906 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1907 (1, self.common_fields.channel_type, option),
1910 encode_tlv_stream!(w, {
1911 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1912 (1, self.common_fields.channel_type, option),
1913 (4, self.next_local_nonce, option),
1919 impl Readable for AcceptChannel {
1920 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1921 let temporary_channel_id: ChannelId = Readable::read(r)?;
1922 let dust_limit_satoshis: u64 = Readable::read(r)?;
1923 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1924 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1925 let htlc_minimum_msat: u64 = Readable::read(r)?;
1926 let minimum_depth: u32 = Readable::read(r)?;
1927 let to_self_delay: u16 = Readable::read(r)?;
1928 let max_accepted_htlcs: u16 = Readable::read(r)?;
1929 let funding_pubkey: PublicKey = Readable::read(r)?;
1930 let revocation_basepoint: PublicKey = Readable::read(r)?;
1931 let payment_basepoint: PublicKey = Readable::read(r)?;
1932 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1933 let htlc_basepoint: PublicKey = Readable::read(r)?;
1934 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1936 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1937 let mut channel_type: Option<ChannelTypeFeatures> = None;
1938 #[cfg(not(taproot))]
1939 decode_tlv_stream!(r, {
1940 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1941 (1, channel_type, option),
1944 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1946 decode_tlv_stream!(r, {
1947 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1948 (1, channel_type, option),
1949 (4, next_local_nonce, option),
1953 common_fields: CommonAcceptChannelFields {
1954 temporary_channel_id,
1955 dust_limit_satoshis,
1956 max_htlc_value_in_flight_msat,
1962 revocation_basepoint,
1964 delayed_payment_basepoint,
1966 first_per_commitment_point,
1967 shutdown_scriptpubkey,
1970 channel_reserve_satoshis,
1977 impl Writeable for AcceptChannelV2 {
1978 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1979 self.common_fields.temporary_channel_id.write(w)?;
1980 self.funding_satoshis.write(w)?;
1981 self.common_fields.dust_limit_satoshis.write(w)?;
1982 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1983 self.common_fields.htlc_minimum_msat.write(w)?;
1984 self.common_fields.minimum_depth.write(w)?;
1985 self.common_fields.to_self_delay.write(w)?;
1986 self.common_fields.max_accepted_htlcs.write(w)?;
1987 self.common_fields.funding_pubkey.write(w)?;
1988 self.common_fields.revocation_basepoint.write(w)?;
1989 self.common_fields.payment_basepoint.write(w)?;
1990 self.common_fields.delayed_payment_basepoint.write(w)?;
1991 self.common_fields.htlc_basepoint.write(w)?;
1992 self.common_fields.first_per_commitment_point.write(w)?;
1993 self.second_per_commitment_point.write(w)?;
1995 encode_tlv_stream!(w, {
1996 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1997 (1, self.common_fields.channel_type, option),
1998 (2, self.require_confirmed_inputs, option),
2004 impl Readable for AcceptChannelV2 {
2005 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2006 let temporary_channel_id: ChannelId = Readable::read(r)?;
2007 let funding_satoshis: u64 = Readable::read(r)?;
2008 let dust_limit_satoshis: u64 = Readable::read(r)?;
2009 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2010 let htlc_minimum_msat: u64 = Readable::read(r)?;
2011 let minimum_depth: u32 = Readable::read(r)?;
2012 let to_self_delay: u16 = Readable::read(r)?;
2013 let max_accepted_htlcs: u16 = Readable::read(r)?;
2014 let funding_pubkey: PublicKey = Readable::read(r)?;
2015 let revocation_basepoint: PublicKey = Readable::read(r)?;
2016 let payment_basepoint: PublicKey = Readable::read(r)?;
2017 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2018 let htlc_basepoint: PublicKey = Readable::read(r)?;
2019 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2020 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2022 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2023 let mut channel_type: Option<ChannelTypeFeatures> = None;
2024 let mut require_confirmed_inputs: Option<()> = None;
2025 decode_tlv_stream!(r, {
2026 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2027 (1, channel_type, option),
2028 (2, require_confirmed_inputs, option),
2031 Ok(AcceptChannelV2 {
2032 common_fields: CommonAcceptChannelFields {
2033 temporary_channel_id,
2034 dust_limit_satoshis,
2035 max_htlc_value_in_flight_msat,
2041 revocation_basepoint,
2043 delayed_payment_basepoint,
2045 first_per_commitment_point,
2046 shutdown_scriptpubkey,
2050 second_per_commitment_point,
2051 require_confirmed_inputs,
2056 impl_writeable_msg!(Stfu, {
2061 impl_writeable_msg!(Splice, {
2065 funding_feerate_perkw,
2070 impl_writeable_msg!(SpliceAck, {
2077 impl_writeable_msg!(SpliceLocked, {
2081 impl_writeable_msg!(TxAddInput, {
2089 impl_writeable_msg!(TxAddOutput, {
2096 impl_writeable_msg!(TxRemoveInput, {
2101 impl_writeable_msg!(TxRemoveOutput, {
2106 impl_writeable_msg!(TxComplete, {
2110 impl_writeable_msg!(TxSignatures, {
2116 impl_writeable_msg!(TxInitRbf, {
2119 feerate_sat_per_1000_weight,
2121 (0, funding_output_contribution, option),
2124 impl_writeable_msg!(TxAckRbf, {
2127 (0, funding_output_contribution, option),
2130 impl_writeable_msg!(TxAbort, {
2135 impl_writeable_msg!(AnnouncementSignatures, {
2142 impl_writeable_msg!(ChannelReestablish, {
2144 next_local_commitment_number,
2145 next_remote_commitment_number,
2146 your_last_per_commitment_secret,
2147 my_current_per_commitment_point,
2149 (0, next_funding_txid, option),
2152 impl_writeable_msg!(ClosingSigned,
2153 { channel_id, fee_satoshis, signature },
2154 { (1, fee_range, option) }
2157 impl_writeable!(ClosingSignedFeeRange, {
2162 #[cfg(not(taproot))]
2163 impl_writeable_msg!(CommitmentSigned, {
2170 impl_writeable_msg!(CommitmentSigned, {
2175 (2, partial_signature_with_nonce, option)
2178 impl_writeable!(DecodedOnionErrorPacket, {
2184 #[cfg(not(taproot))]
2185 impl_writeable_msg!(FundingCreated, {
2186 temporary_channel_id,
2188 funding_output_index,
2192 impl_writeable_msg!(FundingCreated, {
2193 temporary_channel_id,
2195 funding_output_index,
2198 (2, partial_signature_with_nonce, option),
2199 (4, next_local_nonce, option)
2202 #[cfg(not(taproot))]
2203 impl_writeable_msg!(FundingSigned, {
2209 impl_writeable_msg!(FundingSigned, {
2213 (2, partial_signature_with_nonce, option)
2216 impl_writeable_msg!(ChannelReady, {
2218 next_per_commitment_point,
2220 (1, short_channel_id_alias, option),
2223 impl Writeable for Init {
2224 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2225 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2226 // our relevant feature bits. This keeps us compatible with old nodes.
2227 self.features.write_up_to_13(w)?;
2228 self.features.write(w)?;
2229 encode_tlv_stream!(w, {
2230 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2231 (3, self.remote_network_address, option),
2237 impl Readable for Init {
2238 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2239 let global_features: InitFeatures = Readable::read(r)?;
2240 let features: InitFeatures = Readable::read(r)?;
2241 let mut remote_network_address: Option<SocketAddress> = None;
2242 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2243 decode_tlv_stream!(r, {
2244 (1, networks, option),
2245 (3, remote_network_address, option)
2248 features: features | global_features,
2249 networks: networks.map(|n| n.0),
2250 remote_network_address,
2255 impl Writeable for OpenChannel {
2256 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2257 self.common_fields.chain_hash.write(w)?;
2258 self.common_fields.temporary_channel_id.write(w)?;
2259 self.common_fields.funding_satoshis.write(w)?;
2260 self.push_msat.write(w)?;
2261 self.common_fields.dust_limit_satoshis.write(w)?;
2262 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2263 self.channel_reserve_satoshis.write(w)?;
2264 self.common_fields.htlc_minimum_msat.write(w)?;
2265 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2266 self.common_fields.to_self_delay.write(w)?;
2267 self.common_fields.max_accepted_htlcs.write(w)?;
2268 self.common_fields.funding_pubkey.write(w)?;
2269 self.common_fields.revocation_basepoint.write(w)?;
2270 self.common_fields.payment_basepoint.write(w)?;
2271 self.common_fields.delayed_payment_basepoint.write(w)?;
2272 self.common_fields.htlc_basepoint.write(w)?;
2273 self.common_fields.first_per_commitment_point.write(w)?;
2274 self.common_fields.channel_flags.write(w)?;
2275 encode_tlv_stream!(w, {
2276 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2277 (1, self.common_fields.channel_type, option),
2283 impl Readable for OpenChannel {
2284 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2285 let chain_hash: ChainHash = Readable::read(r)?;
2286 let temporary_channel_id: ChannelId = Readable::read(r)?;
2287 let funding_satoshis: u64 = Readable::read(r)?;
2288 let push_msat: u64 = Readable::read(r)?;
2289 let dust_limit_satoshis: u64 = Readable::read(r)?;
2290 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2291 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2292 let htlc_minimum_msat: u64 = Readable::read(r)?;
2293 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2294 let to_self_delay: u16 = Readable::read(r)?;
2295 let max_accepted_htlcs: u16 = Readable::read(r)?;
2296 let funding_pubkey: PublicKey = Readable::read(r)?;
2297 let revocation_basepoint: PublicKey = Readable::read(r)?;
2298 let payment_basepoint: PublicKey = Readable::read(r)?;
2299 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2300 let htlc_basepoint: PublicKey = Readable::read(r)?;
2301 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2302 let channel_flags: u8 = Readable::read(r)?;
2304 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2305 let mut channel_type: Option<ChannelTypeFeatures> = None;
2306 decode_tlv_stream!(r, {
2307 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2308 (1, channel_type, option),
2311 common_fields: CommonOpenChannelFields {
2313 temporary_channel_id,
2315 dust_limit_satoshis,
2316 max_htlc_value_in_flight_msat,
2318 commitment_feerate_sat_per_1000_weight,
2322 revocation_basepoint,
2324 delayed_payment_basepoint,
2326 first_per_commitment_point,
2328 shutdown_scriptpubkey,
2332 channel_reserve_satoshis,
2337 impl Writeable for OpenChannelV2 {
2338 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2339 self.common_fields.chain_hash.write(w)?;
2340 self.common_fields.temporary_channel_id.write(w)?;
2341 self.funding_feerate_sat_per_1000_weight.write(w)?;
2342 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2343 self.common_fields.funding_satoshis.write(w)?;
2344 self.common_fields.dust_limit_satoshis.write(w)?;
2345 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2346 self.common_fields.htlc_minimum_msat.write(w)?;
2347 self.common_fields.to_self_delay.write(w)?;
2348 self.common_fields.max_accepted_htlcs.write(w)?;
2349 self.locktime.write(w)?;
2350 self.common_fields.funding_pubkey.write(w)?;
2351 self.common_fields.revocation_basepoint.write(w)?;
2352 self.common_fields.payment_basepoint.write(w)?;
2353 self.common_fields.delayed_payment_basepoint.write(w)?;
2354 self.common_fields.htlc_basepoint.write(w)?;
2355 self.common_fields.first_per_commitment_point.write(w)?;
2356 self.second_per_commitment_point.write(w)?;
2357 self.common_fields.channel_flags.write(w)?;
2358 encode_tlv_stream!(w, {
2359 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2360 (1, self.common_fields.channel_type, option),
2361 (2, self.require_confirmed_inputs, option),
2367 impl Readable for OpenChannelV2 {
2368 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2369 let chain_hash: ChainHash = Readable::read(r)?;
2370 let temporary_channel_id: ChannelId = Readable::read(r)?;
2371 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2372 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2373 let funding_satoshis: u64 = Readable::read(r)?;
2374 let dust_limit_satoshis: u64 = Readable::read(r)?;
2375 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2376 let htlc_minimum_msat: u64 = Readable::read(r)?;
2377 let to_self_delay: u16 = Readable::read(r)?;
2378 let max_accepted_htlcs: u16 = Readable::read(r)?;
2379 let locktime: u32 = Readable::read(r)?;
2380 let funding_pubkey: PublicKey = Readable::read(r)?;
2381 let revocation_basepoint: PublicKey = Readable::read(r)?;
2382 let payment_basepoint: PublicKey = Readable::read(r)?;
2383 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2384 let htlc_basepoint: PublicKey = Readable::read(r)?;
2385 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2386 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2387 let channel_flags: u8 = Readable::read(r)?;
2389 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2390 let mut channel_type: Option<ChannelTypeFeatures> = None;
2391 let mut require_confirmed_inputs: Option<()> = None;
2392 decode_tlv_stream!(r, {
2393 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2394 (1, channel_type, option),
2395 (2, require_confirmed_inputs, option),
2398 common_fields: CommonOpenChannelFields {
2400 temporary_channel_id,
2402 dust_limit_satoshis,
2403 max_htlc_value_in_flight_msat,
2405 commitment_feerate_sat_per_1000_weight,
2409 revocation_basepoint,
2411 delayed_payment_basepoint,
2413 first_per_commitment_point,
2415 shutdown_scriptpubkey,
2418 funding_feerate_sat_per_1000_weight,
2420 second_per_commitment_point,
2421 require_confirmed_inputs,
2426 #[cfg(not(taproot))]
2427 impl_writeable_msg!(RevokeAndACK, {
2429 per_commitment_secret,
2430 next_per_commitment_point
2434 impl_writeable_msg!(RevokeAndACK, {
2436 per_commitment_secret,
2437 next_per_commitment_point
2439 (4, next_local_nonce, option)
2442 impl_writeable_msg!(Shutdown, {
2447 impl_writeable_msg!(UpdateFailHTLC, {
2453 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2460 impl_writeable_msg!(UpdateFee, {
2465 impl_writeable_msg!(UpdateFulfillHTLC, {
2471 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2472 // serialization format in a way which assumes we know the total serialized length/message end
2474 impl_writeable!(OnionErrorPacket, {
2478 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2479 // serialization format in a way which assumes we know the total serialized length/message end
2481 impl Writeable for OnionPacket {
2482 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2483 self.version.write(w)?;
2484 match self.public_key {
2485 Ok(pubkey) => pubkey.write(w)?,
2486 Err(_) => [0u8;33].write(w)?,
2488 w.write_all(&self.hop_data)?;
2489 self.hmac.write(w)?;
2494 impl Readable for OnionPacket {
2495 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2497 version: Readable::read(r)?,
2499 let mut buf = [0u8;33];
2500 r.read_exact(&mut buf)?;
2501 PublicKey::from_slice(&buf)
2503 hop_data: Readable::read(r)?,
2504 hmac: Readable::read(r)?,
2509 impl_writeable_msg!(UpdateAddHTLC, {
2515 onion_routing_packet,
2517 (0, blinding_point, option),
2518 (65537, skimmed_fee_msat, option)
2521 impl Readable for OnionMessage {
2522 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2523 let blinding_point: PublicKey = Readable::read(r)?;
2524 let len: u16 = Readable::read(r)?;
2525 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2526 let onion_routing_packet: onion_message::packet::Packet =
2527 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2530 onion_routing_packet,
2535 impl Writeable for OnionMessage {
2536 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2537 self.blinding_point.write(w)?;
2538 let onion_packet_len = self.onion_routing_packet.serialized_length();
2539 (onion_packet_len as u16).write(w)?;
2540 self.onion_routing_packet.write(w)?;
2545 impl Writeable for FinalOnionHopData {
2546 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2547 self.payment_secret.0.write(w)?;
2548 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2552 impl Readable for FinalOnionHopData {
2553 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2554 let secret: [u8; 32] = Readable::read(r)?;
2555 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2556 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2560 impl Writeable for OutboundOnionPayload {
2561 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2563 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2564 _encode_varint_length_prefixed_tlv!(w, {
2565 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2566 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2567 (6, short_channel_id, required)
2570 Self::TrampolineEntrypoint {
2571 amt_to_forward, outgoing_cltv_value, ref multipath_trampoline_data,
2572 ref trampoline_packet
2574 _encode_varint_length_prefixed_tlv!(w, {
2575 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2576 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2577 (8, multipath_trampoline_data, option),
2578 (20, trampoline_packet, required)
2582 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2583 cltv_expiry_height, ref custom_tlvs,
2585 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2586 // to reject any reserved types in the experimental range if new ones are ever
2588 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2589 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2590 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2591 _encode_varint_length_prefixed_tlv!(w, {
2592 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2593 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2594 (8, payment_data, option),
2595 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2596 }, custom_tlvs.iter());
2598 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2599 _encode_varint_length_prefixed_tlv!(w, {
2600 (10, *encrypted_tlvs, required_vec),
2601 (12, intro_node_blinding_point, option)
2604 Self::BlindedReceive {
2605 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2606 intro_node_blinding_point, keysend_preimage,
2608 _encode_varint_length_prefixed_tlv!(w, {
2609 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2610 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2611 (10, *encrypted_tlvs, required_vec),
2612 (12, intro_node_blinding_point, option),
2613 (18, HighZeroBytesDroppedBigSize(*total_msat), required),
2614 (5482373484, keysend_preimage, option)
2622 impl Writeable for OutboundTrampolinePayload {
2623 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2625 Self::Forward { amt_to_forward, outgoing_cltv_value, outgoing_node_id } => {
2626 _encode_varint_length_prefixed_tlv!(w, {
2627 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2628 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2629 (14, outgoing_node_id, required)
2638 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2639 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2640 let (update_add_blinding_point, node_signer) = args;
2643 let mut cltv_value = None;
2644 let mut short_id: Option<u64> = None;
2645 let mut payment_data: Option<FinalOnionHopData> = None;
2646 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2647 let mut intro_node_blinding_point = None;
2648 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2649 let mut total_msat = None;
2650 let mut keysend_preimage: Option<PaymentPreimage> = None;
2651 let mut custom_tlvs = Vec::new();
2653 let tlv_len = BigSize::read(r)?;
2654 let rd = FixedLengthReader::new(r, tlv_len.0);
2655 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2656 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2657 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2658 (6, short_id, option),
2659 (8, payment_data, option),
2660 (10, encrypted_tlvs_opt, option),
2661 (12, intro_node_blinding_point, option),
2662 (16, payment_metadata, option),
2663 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2664 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2665 (5482373484, keysend_preimage, option)
2666 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2667 if msg_type < 1 << 16 { return Ok(false) }
2668 let mut value = Vec::new();
2669 msg_reader.read_to_end(&mut value)?;
2670 custom_tlvs.push((msg_type, value));
2674 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2675 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2676 return Err(DecodeError::InvalidValue)
2679 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2680 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2681 return Err(DecodeError::InvalidValue)
2683 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2684 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2685 .map_err(|_| DecodeError::InvalidValue)?;
2686 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2687 let mut s = Cursor::new(&enc_tlvs);
2688 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2689 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2690 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2691 short_channel_id, payment_relay, payment_constraints, features
2693 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2694 keysend_preimage.is_some()
2696 return Err(DecodeError::InvalidValue)
2698 Ok(Self::BlindedForward {
2701 payment_constraints,
2703 intro_node_blinding_point,
2706 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2707 payment_secret, payment_constraints
2709 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2710 Ok(Self::BlindedReceive {
2711 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2712 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2713 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2715 payment_constraints,
2716 intro_node_blinding_point,
2721 } else if let Some(short_channel_id) = short_id {
2722 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2723 total_msat.is_some()
2724 { return Err(DecodeError::InvalidValue) }
2727 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2728 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2731 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2732 return Err(DecodeError::InvalidValue)
2734 if let Some(data) = &payment_data {
2735 if data.total_msat > MAX_VALUE_MSAT {
2736 return Err(DecodeError::InvalidValue);
2741 payment_metadata: payment_metadata.map(|w| w.0),
2743 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2744 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2751 impl Writeable for Ping {
2752 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2753 self.ponglen.write(w)?;
2754 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2759 impl Readable for Ping {
2760 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2762 ponglen: Readable::read(r)?,
2764 let byteslen = Readable::read(r)?;
2765 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2772 impl Writeable for Pong {
2773 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2774 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2779 impl Readable for Pong {
2780 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2783 let byteslen = Readable::read(r)?;
2784 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2791 impl Writeable for UnsignedChannelAnnouncement {
2792 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2793 self.features.write(w)?;
2794 self.chain_hash.write(w)?;
2795 self.short_channel_id.write(w)?;
2796 self.node_id_1.write(w)?;
2797 self.node_id_2.write(w)?;
2798 self.bitcoin_key_1.write(w)?;
2799 self.bitcoin_key_2.write(w)?;
2800 w.write_all(&self.excess_data[..])?;
2805 impl Readable for UnsignedChannelAnnouncement {
2806 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2808 features: Readable::read(r)?,
2809 chain_hash: Readable::read(r)?,
2810 short_channel_id: Readable::read(r)?,
2811 node_id_1: Readable::read(r)?,
2812 node_id_2: Readable::read(r)?,
2813 bitcoin_key_1: Readable::read(r)?,
2814 bitcoin_key_2: Readable::read(r)?,
2815 excess_data: read_to_end(r)?,
2820 impl_writeable!(ChannelAnnouncement, {
2823 bitcoin_signature_1,
2824 bitcoin_signature_2,
2828 impl Writeable for UnsignedChannelUpdate {
2829 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2830 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2831 const MESSAGE_FLAGS: u8 = 1;
2832 self.chain_hash.write(w)?;
2833 self.short_channel_id.write(w)?;
2834 self.timestamp.write(w)?;
2835 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2836 all_flags.write(w)?;
2837 self.cltv_expiry_delta.write(w)?;
2838 self.htlc_minimum_msat.write(w)?;
2839 self.fee_base_msat.write(w)?;
2840 self.fee_proportional_millionths.write(w)?;
2841 self.htlc_maximum_msat.write(w)?;
2842 w.write_all(&self.excess_data[..])?;
2847 impl Readable for UnsignedChannelUpdate {
2848 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2850 chain_hash: Readable::read(r)?,
2851 short_channel_id: Readable::read(r)?,
2852 timestamp: Readable::read(r)?,
2854 let flags: u16 = Readable::read(r)?;
2855 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2858 cltv_expiry_delta: Readable::read(r)?,
2859 htlc_minimum_msat: Readable::read(r)?,
2860 fee_base_msat: Readable::read(r)?,
2861 fee_proportional_millionths: Readable::read(r)?,
2862 htlc_maximum_msat: Readable::read(r)?,
2863 excess_data: read_to_end(r)?,
2868 impl_writeable!(ChannelUpdate, {
2873 impl Writeable for ErrorMessage {
2874 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2875 self.channel_id.write(w)?;
2876 (self.data.len() as u16).write(w)?;
2877 w.write_all(self.data.as_bytes())?;
2882 impl Readable for ErrorMessage {
2883 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2885 channel_id: Readable::read(r)?,
2887 let sz: usize = <u16 as Readable>::read(r)? as usize;
2888 let mut data = Vec::with_capacity(sz);
2890 r.read_exact(&mut data)?;
2891 match String::from_utf8(data) {
2893 Err(_) => return Err(DecodeError::InvalidValue),
2900 impl Writeable for WarningMessage {
2901 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2902 self.channel_id.write(w)?;
2903 (self.data.len() as u16).write(w)?;
2904 w.write_all(self.data.as_bytes())?;
2909 impl Readable for WarningMessage {
2910 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2912 channel_id: Readable::read(r)?,
2914 let sz: usize = <u16 as Readable>::read(r)? as usize;
2915 let mut data = Vec::with_capacity(sz);
2917 r.read_exact(&mut data)?;
2918 match String::from_utf8(data) {
2920 Err(_) => return Err(DecodeError::InvalidValue),
2927 impl Writeable for UnsignedNodeAnnouncement {
2928 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2929 self.features.write(w)?;
2930 self.timestamp.write(w)?;
2931 self.node_id.write(w)?;
2932 w.write_all(&self.rgb)?;
2933 self.alias.write(w)?;
2935 let mut addr_len = 0;
2936 for addr in self.addresses.iter() {
2937 addr_len += 1 + addr.len();
2939 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2940 for addr in self.addresses.iter() {
2943 w.write_all(&self.excess_address_data[..])?;
2944 w.write_all(&self.excess_data[..])?;
2949 impl Readable for UnsignedNodeAnnouncement {
2950 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2951 let features: NodeFeatures = Readable::read(r)?;
2952 let timestamp: u32 = Readable::read(r)?;
2953 let node_id: NodeId = Readable::read(r)?;
2954 let mut rgb = [0; 3];
2955 r.read_exact(&mut rgb)?;
2956 let alias: NodeAlias = Readable::read(r)?;
2958 let addr_len: u16 = Readable::read(r)?;
2959 let mut addresses: Vec<SocketAddress> = Vec::new();
2960 let mut addr_readpos = 0;
2961 let mut excess = false;
2962 let mut excess_byte = 0;
2964 if addr_len <= addr_readpos { break; }
2965 match Readable::read(r) {
2967 if addr_len < addr_readpos + 1 + addr.len() {
2968 return Err(DecodeError::BadLengthDescriptor);
2970 addr_readpos += (1 + addr.len()) as u16;
2971 addresses.push(addr);
2973 Ok(Err(unknown_descriptor)) => {
2975 excess_byte = unknown_descriptor;
2978 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2979 Err(e) => return Err(e),
2983 let mut excess_data = vec![];
2984 let excess_address_data = if addr_readpos < addr_len {
2985 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2986 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2988 excess_address_data[0] = excess_byte;
2993 excess_data.push(excess_byte);
2997 excess_data.extend(read_to_end(r)?.iter());
2998 Ok(UnsignedNodeAnnouncement {
3005 excess_address_data,
3011 impl_writeable!(NodeAnnouncement, {
3016 impl Readable for QueryShortChannelIds {
3017 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3018 let chain_hash: ChainHash = Readable::read(r)?;
3020 let encoding_len: u16 = Readable::read(r)?;
3021 let encoding_type: u8 = Readable::read(r)?;
3023 // Must be encoding_type=0 uncompressed serialization. We do not
3024 // support encoding_type=1 zlib serialization.
3025 if encoding_type != EncodingType::Uncompressed as u8 {
3026 return Err(DecodeError::UnsupportedCompression);
3029 // We expect the encoding_len to always includes the 1-byte
3030 // encoding_type and that short_channel_ids are 8-bytes each
3031 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3032 return Err(DecodeError::InvalidValue);
3035 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3036 // less the 1-byte encoding_type
3037 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3038 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3039 for _ in 0..short_channel_id_count {
3040 short_channel_ids.push(Readable::read(r)?);
3043 Ok(QueryShortChannelIds {
3050 impl Writeable for QueryShortChannelIds {
3051 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3052 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
3053 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3055 self.chain_hash.write(w)?;
3056 encoding_len.write(w)?;
3058 // We only support type=0 uncompressed serialization
3059 (EncodingType::Uncompressed as u8).write(w)?;
3061 for scid in self.short_channel_ids.iter() {
3069 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3074 impl QueryChannelRange {
3075 /// Calculates the overflow safe ending block height for the query.
3077 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3078 pub fn end_blocknum(&self) -> u32 {
3079 match self.first_blocknum.checked_add(self.number_of_blocks) {
3080 Some(block) => block,
3081 None => u32::max_value(),
3086 impl_writeable_msg!(QueryChannelRange, {
3092 impl Readable for ReplyChannelRange {
3093 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3094 let chain_hash: ChainHash = Readable::read(r)?;
3095 let first_blocknum: u32 = Readable::read(r)?;
3096 let number_of_blocks: u32 = Readable::read(r)?;
3097 let sync_complete: bool = Readable::read(r)?;
3099 let encoding_len: u16 = Readable::read(r)?;
3100 let encoding_type: u8 = Readable::read(r)?;
3102 // Must be encoding_type=0 uncompressed serialization. We do not
3103 // support encoding_type=1 zlib serialization.
3104 if encoding_type != EncodingType::Uncompressed as u8 {
3105 return Err(DecodeError::UnsupportedCompression);
3108 // We expect the encoding_len to always includes the 1-byte
3109 // encoding_type and that short_channel_ids are 8-bytes each
3110 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3111 return Err(DecodeError::InvalidValue);
3114 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3115 // less the 1-byte encoding_type
3116 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3117 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3118 for _ in 0..short_channel_id_count {
3119 short_channel_ids.push(Readable::read(r)?);
3122 Ok(ReplyChannelRange {
3132 impl Writeable for ReplyChannelRange {
3133 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3134 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3135 self.chain_hash.write(w)?;
3136 self.first_blocknum.write(w)?;
3137 self.number_of_blocks.write(w)?;
3138 self.sync_complete.write(w)?;
3140 encoding_len.write(w)?;
3141 (EncodingType::Uncompressed as u8).write(w)?;
3142 for scid in self.short_channel_ids.iter() {
3150 impl_writeable_msg!(GossipTimestampFilter, {
3158 use std::convert::TryFrom;
3159 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3160 use hex::DisplayHex;
3161 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
3162 use crate::ln::ChannelId;
3163 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3164 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
3165 use crate::ln::msgs::SocketAddress;
3166 use crate::routing::gossip::{NodeAlias, NodeId};
3167 use crate::util::ser::{BigSize, Hostname, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
3168 use crate::util::test_utils;
3170 use bitcoin::hashes::hex::FromHex;
3171 use bitcoin::address::Address;
3172 use bitcoin::network::constants::Network;
3173 use bitcoin::blockdata::constants::ChainHash;
3174 use bitcoin::blockdata::script::Builder;
3175 use bitcoin::blockdata::opcodes;
3176 use bitcoin::hash_types::Txid;
3177 use bitcoin::locktime::absolute::LockTime;
3179 use bitcoin::secp256k1::{PublicKey,SecretKey};
3180 use bitcoin::secp256k1::{Secp256k1, Message};
3182 use crate::io::{self, Cursor};
3183 use crate::prelude::*;
3184 use core::str::FromStr;
3185 use crate::chain::transaction::OutPoint;
3187 #[cfg(feature = "std")]
3188 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3189 #[cfg(feature = "std")]
3190 use crate::ln::msgs::SocketAddressParseError;
3193 fn encoding_channel_reestablish() {
3195 let secp_ctx = Secp256k1::new();
3196 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3199 let cr = msgs::ChannelReestablish {
3200 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]),
3201 next_local_commitment_number: 3,
3202 next_remote_commitment_number: 4,
3203 your_last_per_commitment_secret: [9;32],
3204 my_current_per_commitment_point: public_key,
3205 next_funding_txid: None,
3208 let encoded_value = cr.encode();
3212 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
3213 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3214 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3215 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
3216 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
3222 fn encoding_channel_reestablish_with_next_funding_txid() {
3224 let secp_ctx = Secp256k1::new();
3225 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3228 let cr = msgs::ChannelReestablish {
3229 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]),
3230 next_local_commitment_number: 3,
3231 next_remote_commitment_number: 4,
3232 your_last_per_commitment_secret: [9;32],
3233 my_current_per_commitment_point: public_key,
3234 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3235 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,
3239 let encoded_value = cr.encode();
3243 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
3244 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3245 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3246 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
3247 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
3248 0, // Type (next_funding_txid)
3250 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
3255 macro_rules! get_keys_from {
3256 ($slice: expr, $secp_ctx: expr) => {
3258 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3259 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3265 macro_rules! get_sig_on {
3266 ($privkey: expr, $ctx: expr, $string: expr) => {
3268 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
3269 $ctx.sign_ecdsa(&sighash, &$privkey)
3275 fn encoding_announcement_signatures() {
3276 let secp_ctx = Secp256k1::new();
3277 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3278 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3279 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3280 let announcement_signatures = msgs::AnnouncementSignatures {
3281 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]),
3282 short_channel_id: 2316138423780173,
3283 node_signature: sig_1,
3284 bitcoin_signature: sig_2,
3287 let encoded_value = announcement_signatures.encode();
3288 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3291 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3292 let secp_ctx = Secp256k1::new();
3293 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3294 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3295 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3296 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3297 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3298 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3299 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3300 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3301 let mut features = ChannelFeatures::empty();
3302 if unknown_features_bits {
3303 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3305 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3307 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3308 short_channel_id: 2316138423780173,
3309 node_id_1: NodeId::from_pubkey(&pubkey_1),
3310 node_id_2: NodeId::from_pubkey(&pubkey_2),
3311 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3312 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3313 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3315 let channel_announcement = msgs::ChannelAnnouncement {
3316 node_signature_1: sig_1,
3317 node_signature_2: sig_2,
3318 bitcoin_signature_1: sig_3,
3319 bitcoin_signature_2: sig_4,
3320 contents: unsigned_channel_announcement,
3322 let encoded_value = channel_announcement.encode();
3323 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3324 if unknown_features_bits {
3325 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3327 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3329 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3330 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3332 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3334 assert_eq!(encoded_value, target_value);
3338 fn encoding_channel_announcement() {
3339 do_encoding_channel_announcement(true, false);
3340 do_encoding_channel_announcement(false, true);
3341 do_encoding_channel_announcement(false, false);
3342 do_encoding_channel_announcement(true, true);
3345 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) {
3346 let secp_ctx = Secp256k1::new();
3347 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3348 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3349 let features = if unknown_features_bits {
3350 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3352 // Set to some features we may support
3353 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3355 let mut addresses = Vec::new();
3357 addresses.push(SocketAddress::TcpIpV4 {
3358 addr: [255, 254, 253, 252],
3363 addresses.push(SocketAddress::TcpIpV6 {
3364 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3369 addresses.push(msgs::SocketAddress::OnionV2(
3370 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3374 addresses.push(msgs::SocketAddress::OnionV3 {
3375 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],
3382 addresses.push(SocketAddress::Hostname {
3383 hostname: Hostname::try_from(String::from("host")).unwrap(),
3387 let mut addr_len = 0;
3388 for addr in &addresses {
3389 addr_len += addr.len() + 1;
3391 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3393 timestamp: 20190119,
3394 node_id: NodeId::from_pubkey(&pubkey_1),
3396 alias: NodeAlias([16;32]),
3398 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() },
3399 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() },
3401 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3402 let node_announcement = msgs::NodeAnnouncement {
3404 contents: unsigned_node_announcement,
3406 let encoded_value = node_announcement.encode();
3407 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3408 if unknown_features_bits {
3409 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3411 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3413 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3414 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3416 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3419 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3422 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3425 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3428 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3430 if excess_address_data {
3431 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3434 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3436 assert_eq!(encoded_value, target_value);
3440 fn encoding_node_announcement() {
3441 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3442 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3443 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3444 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3445 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3446 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3447 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3448 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3449 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3450 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3453 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3454 let secp_ctx = Secp256k1::new();
3455 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3456 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3457 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3458 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3459 short_channel_id: 2316138423780173,
3460 timestamp: 20190119,
3461 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3462 cltv_expiry_delta: 144,
3463 htlc_minimum_msat: 1000000,
3464 htlc_maximum_msat: 131355275467161,
3465 fee_base_msat: 10000,
3466 fee_proportional_millionths: 20,
3467 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3469 let channel_update = msgs::ChannelUpdate {
3471 contents: unsigned_channel_update
3473 let encoded_value = channel_update.encode();
3474 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3475 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3476 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3477 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3478 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3480 let flag = target_value.last_mut().unwrap();
3484 let flag = target_value.last_mut().unwrap();
3485 *flag = *flag | 1 << 1;
3487 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3488 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3490 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3492 assert_eq!(encoded_value, target_value);
3496 fn encoding_channel_update() {
3497 do_encoding_channel_update(false, false, false);
3498 do_encoding_channel_update(false, false, true);
3499 do_encoding_channel_update(true, false, false);
3500 do_encoding_channel_update(true, false, true);
3501 do_encoding_channel_update(false, true, false);
3502 do_encoding_channel_update(false, true, true);
3503 do_encoding_channel_update(true, true, false);
3504 do_encoding_channel_update(true, true, true);
3507 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3508 let secp_ctx = Secp256k1::new();
3509 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3510 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3511 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3512 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3513 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3514 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3515 let open_channel = msgs::OpenChannel {
3516 common_fields: CommonOpenChannelFields {
3517 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3518 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3519 funding_satoshis: 1311768467284833366,
3520 dust_limit_satoshis: 3608586615801332854,
3521 max_htlc_value_in_flight_msat: 8517154655701053848,
3522 htlc_minimum_msat: 2316138423780173,
3523 commitment_feerate_sat_per_1000_weight: 821716,
3524 to_self_delay: 49340,
3525 max_accepted_htlcs: 49340,
3526 funding_pubkey: pubkey_1,
3527 revocation_basepoint: pubkey_2,
3528 payment_basepoint: pubkey_3,
3529 delayed_payment_basepoint: pubkey_4,
3530 htlc_basepoint: pubkey_5,
3531 first_per_commitment_point: pubkey_6,
3532 channel_flags: if random_bit { 1 << 5 } else { 0 },
3533 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3534 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3536 push_msat: 2536655962884945560,
3537 channel_reserve_satoshis: 8665828695742877976,
3539 let encoded_value = open_channel.encode();
3540 let mut target_value = Vec::new();
3541 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3542 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3544 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3546 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3549 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3552 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3554 assert_eq!(encoded_value, target_value);
3558 fn encoding_open_channel() {
3559 do_encoding_open_channel(false, false, false);
3560 do_encoding_open_channel(false, false, true);
3561 do_encoding_open_channel(false, true, false);
3562 do_encoding_open_channel(false, true, true);
3563 do_encoding_open_channel(true, false, false);
3564 do_encoding_open_channel(true, false, true);
3565 do_encoding_open_channel(true, true, false);
3566 do_encoding_open_channel(true, true, true);
3569 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3570 let secp_ctx = Secp256k1::new();
3571 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3572 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3573 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3574 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3575 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3576 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3577 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3578 let open_channelv2 = msgs::OpenChannelV2 {
3579 common_fields: CommonOpenChannelFields {
3580 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3581 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3582 commitment_feerate_sat_per_1000_weight: 821716,
3583 funding_satoshis: 1311768467284833366,
3584 dust_limit_satoshis: 3608586615801332854,
3585 max_htlc_value_in_flight_msat: 8517154655701053848,
3586 htlc_minimum_msat: 2316138423780173,
3587 to_self_delay: 49340,
3588 max_accepted_htlcs: 49340,
3589 funding_pubkey: pubkey_1,
3590 revocation_basepoint: pubkey_2,
3591 payment_basepoint: pubkey_3,
3592 delayed_payment_basepoint: pubkey_4,
3593 htlc_basepoint: pubkey_5,
3594 first_per_commitment_point: pubkey_6,
3595 channel_flags: if random_bit { 1 << 5 } else { 0 },
3596 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3597 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3599 funding_feerate_sat_per_1000_weight: 821716,
3600 locktime: 305419896,
3601 second_per_commitment_point: pubkey_7,
3602 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3604 let encoded_value = open_channelv2.encode();
3605 let mut target_value = Vec::new();
3606 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3607 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3608 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3609 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3610 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3611 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3612 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3613 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3614 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3615 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3616 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3617 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3618 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3619 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3620 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3621 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3622 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3623 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3626 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3628 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3631 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3634 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3636 if require_confirmed_inputs {
3637 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3639 assert_eq!(encoded_value, target_value);
3643 fn encoding_open_channelv2() {
3644 do_encoding_open_channelv2(false, false, false, false);
3645 do_encoding_open_channelv2(false, false, false, true);
3646 do_encoding_open_channelv2(false, false, true, false);
3647 do_encoding_open_channelv2(false, false, true, true);
3648 do_encoding_open_channelv2(false, true, false, false);
3649 do_encoding_open_channelv2(false, true, false, true);
3650 do_encoding_open_channelv2(false, true, true, false);
3651 do_encoding_open_channelv2(false, true, true, true);
3652 do_encoding_open_channelv2(true, false, false, false);
3653 do_encoding_open_channelv2(true, false, false, true);
3654 do_encoding_open_channelv2(true, false, true, false);
3655 do_encoding_open_channelv2(true, false, true, true);
3656 do_encoding_open_channelv2(true, true, false, false);
3657 do_encoding_open_channelv2(true, true, false, true);
3658 do_encoding_open_channelv2(true, true, true, false);
3659 do_encoding_open_channelv2(true, true, true, true);
3662 fn do_encoding_accept_channel(shutdown: bool) {
3663 let secp_ctx = Secp256k1::new();
3664 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3665 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3666 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3667 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3668 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3669 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3670 let accept_channel = msgs::AcceptChannel {
3671 common_fields: CommonAcceptChannelFields {
3672 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3673 dust_limit_satoshis: 1311768467284833366,
3674 max_htlc_value_in_flight_msat: 2536655962884945560,
3675 htlc_minimum_msat: 2316138423780173,
3676 minimum_depth: 821716,
3677 to_self_delay: 49340,
3678 max_accepted_htlcs: 49340,
3679 funding_pubkey: pubkey_1,
3680 revocation_basepoint: pubkey_2,
3681 payment_basepoint: pubkey_3,
3682 delayed_payment_basepoint: pubkey_4,
3683 htlc_basepoint: pubkey_5,
3684 first_per_commitment_point: pubkey_6,
3685 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3688 channel_reserve_satoshis: 3608586615801332854,
3690 next_local_nonce: None,
3692 let encoded_value = accept_channel.encode();
3693 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3695 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3697 assert_eq!(encoded_value, target_value);
3701 fn encoding_accept_channel() {
3702 do_encoding_accept_channel(false);
3703 do_encoding_accept_channel(true);
3706 fn do_encoding_accept_channelv2(shutdown: bool) {
3707 let secp_ctx = Secp256k1::new();
3708 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3709 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3710 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3711 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3712 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3713 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3714 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3715 let accept_channelv2 = msgs::AcceptChannelV2 {
3716 common_fields: CommonAcceptChannelFields {
3717 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3718 dust_limit_satoshis: 1311768467284833366,
3719 max_htlc_value_in_flight_msat: 2536655962884945560,
3720 htlc_minimum_msat: 2316138423780173,
3721 minimum_depth: 821716,
3722 to_self_delay: 49340,
3723 max_accepted_htlcs: 49340,
3724 funding_pubkey: pubkey_1,
3725 revocation_basepoint: pubkey_2,
3726 payment_basepoint: pubkey_3,
3727 delayed_payment_basepoint: pubkey_4,
3728 htlc_basepoint: pubkey_5,
3729 first_per_commitment_point: pubkey_6,
3730 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3733 funding_satoshis: 1311768467284833366,
3734 second_per_commitment_point: pubkey_7,
3735 require_confirmed_inputs: None,
3737 let encoded_value = accept_channelv2.encode();
3738 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3739 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3740 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3741 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3742 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3743 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3744 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3745 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3746 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3747 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3748 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3749 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3750 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3751 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3752 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3754 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3756 assert_eq!(encoded_value, target_value);
3760 fn encoding_accept_channelv2() {
3761 do_encoding_accept_channelv2(false);
3762 do_encoding_accept_channelv2(true);
3766 fn encoding_funding_created() {
3767 let secp_ctx = Secp256k1::new();
3768 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3769 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3770 let funding_created = msgs::FundingCreated {
3771 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3772 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3773 funding_output_index: 255,
3776 partial_signature_with_nonce: None,
3778 next_local_nonce: None,
3780 let encoded_value = funding_created.encode();
3781 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3782 assert_eq!(encoded_value, target_value);
3786 fn encoding_funding_signed() {
3787 let secp_ctx = Secp256k1::new();
3788 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3789 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3790 let funding_signed = msgs::FundingSigned {
3791 channel_id: ChannelId::from_bytes([2; 32]),
3794 partial_signature_with_nonce: None,
3796 let encoded_value = funding_signed.encode();
3797 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3798 assert_eq!(encoded_value, target_value);
3802 fn encoding_channel_ready() {
3803 let secp_ctx = Secp256k1::new();
3804 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3805 let channel_ready = msgs::ChannelReady {
3806 channel_id: ChannelId::from_bytes([2; 32]),
3807 next_per_commitment_point: pubkey_1,
3808 short_channel_id_alias: None,
3810 let encoded_value = channel_ready.encode();
3811 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3812 assert_eq!(encoded_value, target_value);
3816 fn encoding_splice() {
3817 let secp_ctx = Secp256k1::new();
3818 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3819 let splice = msgs::Splice {
3820 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3821 channel_id: ChannelId::from_bytes([2; 32]),
3822 relative_satoshis: 123456,
3823 funding_feerate_perkw: 2000,
3825 funding_pubkey: pubkey_1,
3827 let encoded_value = splice.encode();
3828 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3832 fn encoding_stfu() {
3833 let stfu = msgs::Stfu {
3834 channel_id: ChannelId::from_bytes([2; 32]),
3837 let encoded_value = stfu.encode();
3838 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3842 fn encoding_splice_ack() {
3843 let secp_ctx = Secp256k1::new();
3844 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3845 let splice = msgs::SpliceAck {
3846 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3847 channel_id: ChannelId::from_bytes([2; 32]),
3848 relative_satoshis: 123456,
3849 funding_pubkey: pubkey_1,
3851 let encoded_value = splice.encode();
3852 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3856 fn encoding_splice_locked() {
3857 let splice = msgs::SpliceLocked {
3858 channel_id: ChannelId::from_bytes([2; 32]),
3860 let encoded_value = splice.encode();
3861 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3865 fn encoding_tx_add_input() {
3866 let tx_add_input = msgs::TxAddInput {
3867 channel_id: ChannelId::from_bytes([2; 32]),
3868 serial_id: 4886718345,
3869 prevtx: TransactionU16LenLimited::new(Transaction {
3871 lock_time: LockTime::ZERO,
3873 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3874 script_sig: ScriptBuf::new(),
3875 sequence: Sequence(0xfffffffd),
3876 witness: Witness::from_slice(&vec![
3877 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3878 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3883 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3887 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3891 prevtx_out: 305419896,
3892 sequence: 305419896,
3894 let encoded_value = tx_add_input.encode();
3895 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3896 assert_eq!(encoded_value, target_value);
3900 fn encoding_tx_add_output() {
3901 let tx_add_output = msgs::TxAddOutput {
3902 channel_id: ChannelId::from_bytes([2; 32]),
3903 serial_id: 4886718345,
3905 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3907 let encoded_value = tx_add_output.encode();
3908 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3909 assert_eq!(encoded_value, target_value);
3913 fn encoding_tx_remove_input() {
3914 let tx_remove_input = msgs::TxRemoveInput {
3915 channel_id: ChannelId::from_bytes([2; 32]),
3916 serial_id: 4886718345,
3918 let encoded_value = tx_remove_input.encode();
3919 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3920 assert_eq!(encoded_value, target_value);
3924 fn encoding_tx_remove_output() {
3925 let tx_remove_output = msgs::TxRemoveOutput {
3926 channel_id: ChannelId::from_bytes([2; 32]),
3927 serial_id: 4886718345,
3929 let encoded_value = tx_remove_output.encode();
3930 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3931 assert_eq!(encoded_value, target_value);
3935 fn encoding_tx_complete() {
3936 let tx_complete = msgs::TxComplete {
3937 channel_id: ChannelId::from_bytes([2; 32]),
3939 let encoded_value = tx_complete.encode();
3940 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3941 assert_eq!(encoded_value, target_value);
3945 fn encoding_tx_signatures() {
3946 let tx_signatures = msgs::TxSignatures {
3947 channel_id: ChannelId::from_bytes([2; 32]),
3948 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3950 Witness::from_slice(&vec![
3951 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3952 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3953 Witness::from_slice(&vec![
3954 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3955 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3958 let encoded_value = tx_signatures.encode();
3959 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3960 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3961 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3963 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3964 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3965 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3966 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3967 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3968 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3970 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3971 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3972 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3973 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3974 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3975 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3976 assert_eq!(encoded_value, target_value);
3979 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3980 let tx_init_rbf = msgs::TxInitRbf {
3981 channel_id: ChannelId::from_bytes([2; 32]),
3982 locktime: 305419896,
3983 feerate_sat_per_1000_weight: 20190119,
3984 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3986 let encoded_value = tx_init_rbf.encode();
3987 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3988 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3989 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3990 if let Some((_, target)) = funding_value_with_hex_target {
3991 target_value.push(0x00); // Type
3992 target_value.push(target.len() as u8 / 2); // Length
3993 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3995 assert_eq!(encoded_value, target_value);
3999 fn encoding_tx_init_rbf() {
4000 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
4001 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
4002 do_encoding_tx_init_rbf(None);
4005 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
4006 let tx_ack_rbf = msgs::TxAckRbf {
4007 channel_id: ChannelId::from_bytes([2; 32]),
4008 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
4010 let encoded_value = tx_ack_rbf.encode();
4011 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4012 if let Some((_, target)) = funding_value_with_hex_target {
4013 target_value.push(0x00); // Type
4014 target_value.push(target.len() as u8 / 2); // Length
4015 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
4017 assert_eq!(encoded_value, target_value);
4021 fn encoding_tx_ack_rbf() {
4022 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
4023 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
4024 do_encoding_tx_ack_rbf(None);
4028 fn encoding_tx_abort() {
4029 let tx_abort = msgs::TxAbort {
4030 channel_id: ChannelId::from_bytes([2; 32]),
4031 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
4033 let encoded_value = tx_abort.encode();
4034 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
4035 assert_eq!(encoded_value, target_value);
4038 fn do_encoding_shutdown(script_type: u8) {
4039 let secp_ctx = Secp256k1::new();
4040 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4041 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
4042 let shutdown = msgs::Shutdown {
4043 channel_id: ChannelId::from_bytes([2; 32]),
4045 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
4046 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
4047 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
4048 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
4050 let encoded_value = shutdown.encode();
4051 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4052 if script_type == 1 {
4053 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
4054 } else if script_type == 2 {
4055 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
4056 } else if script_type == 3 {
4057 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
4058 } else if script_type == 4 {
4059 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
4061 assert_eq!(encoded_value, target_value);
4065 fn encoding_shutdown() {
4066 do_encoding_shutdown(1);
4067 do_encoding_shutdown(2);
4068 do_encoding_shutdown(3);
4069 do_encoding_shutdown(4);
4073 fn encoding_closing_signed() {
4074 let secp_ctx = Secp256k1::new();
4075 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4076 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4077 let closing_signed = msgs::ClosingSigned {
4078 channel_id: ChannelId::from_bytes([2; 32]),
4079 fee_satoshis: 2316138423780173,
4083 let encoded_value = closing_signed.encode();
4084 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4085 assert_eq!(encoded_value, target_value);
4086 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4088 let closing_signed_with_range = msgs::ClosingSigned {
4089 channel_id: ChannelId::from_bytes([2; 32]),
4090 fee_satoshis: 2316138423780173,
4092 fee_range: Some(msgs::ClosingSignedFeeRange {
4093 min_fee_satoshis: 0xdeadbeef,
4094 max_fee_satoshis: 0x1badcafe01234567,
4097 let encoded_value_with_range = closing_signed_with_range.encode();
4098 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4099 assert_eq!(encoded_value_with_range, target_value_with_range);
4100 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4101 closing_signed_with_range);
4105 fn encoding_update_add_htlc() {
4106 let secp_ctx = Secp256k1::new();
4107 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4108 let onion_routing_packet = msgs::OnionPacket {
4110 public_key: Ok(pubkey_1),
4111 hop_data: [1; 20*65],
4114 let update_add_htlc = msgs::UpdateAddHTLC {
4115 channel_id: ChannelId::from_bytes([2; 32]),
4116 htlc_id: 2316138423780173,
4117 amount_msat: 3608586615801332854,
4118 payment_hash: PaymentHash([1; 32]),
4119 cltv_expiry: 821716,
4120 onion_routing_packet,
4121 skimmed_fee_msat: None,
4122 blinding_point: None,
4124 let encoded_value = update_add_htlc.encode();
4125 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4126 assert_eq!(encoded_value, target_value);
4130 fn encoding_update_fulfill_htlc() {
4131 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4132 channel_id: ChannelId::from_bytes([2; 32]),
4133 htlc_id: 2316138423780173,
4134 payment_preimage: PaymentPreimage([1; 32]),
4136 let encoded_value = update_fulfill_htlc.encode();
4137 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4138 assert_eq!(encoded_value, target_value);
4142 fn encoding_update_fail_htlc() {
4143 let reason = OnionErrorPacket {
4144 data: [1; 32].to_vec(),
4146 let update_fail_htlc = msgs::UpdateFailHTLC {
4147 channel_id: ChannelId::from_bytes([2; 32]),
4148 htlc_id: 2316138423780173,
4151 let encoded_value = update_fail_htlc.encode();
4152 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4153 assert_eq!(encoded_value, target_value);
4157 fn encoding_update_fail_malformed_htlc() {
4158 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4159 channel_id: ChannelId::from_bytes([2; 32]),
4160 htlc_id: 2316138423780173,
4161 sha256_of_onion: [1; 32],
4164 let encoded_value = update_fail_malformed_htlc.encode();
4165 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4166 assert_eq!(encoded_value, target_value);
4169 fn do_encoding_commitment_signed(htlcs: bool) {
4170 let secp_ctx = Secp256k1::new();
4171 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4172 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4173 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4174 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4175 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4176 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4177 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4178 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4179 let commitment_signed = msgs::CommitmentSigned {
4180 channel_id: ChannelId::from_bytes([2; 32]),
4182 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4184 partial_signature_with_nonce: None,
4186 let encoded_value = commitment_signed.encode();
4187 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4189 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4191 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4193 assert_eq!(encoded_value, target_value);
4197 fn encoding_commitment_signed() {
4198 do_encoding_commitment_signed(true);
4199 do_encoding_commitment_signed(false);
4203 fn encoding_revoke_and_ack() {
4204 let secp_ctx = Secp256k1::new();
4205 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4206 let raa = msgs::RevokeAndACK {
4207 channel_id: ChannelId::from_bytes([2; 32]),
4208 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],
4209 next_per_commitment_point: pubkey_1,
4211 next_local_nonce: None,
4213 let encoded_value = raa.encode();
4214 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4215 assert_eq!(encoded_value, target_value);
4219 fn encoding_update_fee() {
4220 let update_fee = msgs::UpdateFee {
4221 channel_id: ChannelId::from_bytes([2; 32]),
4222 feerate_per_kw: 20190119,
4224 let encoded_value = update_fee.encode();
4225 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4226 assert_eq!(encoded_value, target_value);
4230 fn encoding_init() {
4231 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4232 assert_eq!(msgs::Init {
4233 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4234 networks: Some(vec![mainnet_hash]),
4235 remote_network_address: None,
4236 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4237 assert_eq!(msgs::Init {
4238 features: InitFeatures::from_le_bytes(vec![0xFF]),
4240 remote_network_address: None,
4241 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4242 assert_eq!(msgs::Init {
4243 features: InitFeatures::from_le_bytes(vec![]),
4244 networks: Some(vec![mainnet_hash]),
4245 remote_network_address: None,
4246 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4247 assert_eq!(msgs::Init {
4248 features: InitFeatures::from_le_bytes(vec![]),
4249 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4250 remote_network_address: None,
4251 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4252 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4253 networks: Some(vec![mainnet_hash]),
4254 remote_network_address: Some(SocketAddress::TcpIpV4 {
4255 addr: [127, 0, 0, 1],
4259 let encoded_value = init_msg.encode();
4260 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4261 assert_eq!(encoded_value, target_value);
4262 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4266 fn encoding_error() {
4267 let error = msgs::ErrorMessage {
4268 channel_id: ChannelId::from_bytes([2; 32]),
4269 data: String::from("rust-lightning"),
4271 let encoded_value = error.encode();
4272 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4273 assert_eq!(encoded_value, target_value);
4277 fn encoding_warning() {
4278 let error = msgs::WarningMessage {
4279 channel_id: ChannelId::from_bytes([2; 32]),
4280 data: String::from("rust-lightning"),
4282 let encoded_value = error.encode();
4283 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4284 assert_eq!(encoded_value, target_value);
4288 fn encoding_ping() {
4289 let ping = msgs::Ping {
4293 let encoded_value = ping.encode();
4294 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4295 assert_eq!(encoded_value, target_value);
4299 fn encoding_pong() {
4300 let pong = msgs::Pong {
4303 let encoded_value = pong.encode();
4304 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4305 assert_eq!(encoded_value, target_value);
4309 fn encoding_nonfinal_onion_hop_data() {
4310 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4311 short_channel_id: 0xdeadbeef1bad1dea,
4312 amt_to_forward: 0x0badf00d01020304,
4313 outgoing_cltv_value: 0xffffffff,
4315 let encoded_value = outbound_msg.encode();
4316 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4317 assert_eq!(encoded_value, target_value);
4319 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4320 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4321 if let msgs::InboundOnionPayload::Forward {
4322 short_channel_id, amt_to_forward, outgoing_cltv_value
4324 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4325 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4326 assert_eq!(outgoing_cltv_value, 0xffffffff);
4327 } else { panic!(); }
4331 fn encoding_final_onion_hop_data() {
4332 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4334 payment_metadata: None,
4335 keysend_preimage: None,
4336 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4337 cltv_expiry_height: 0xffffffff,
4338 custom_tlvs: vec![],
4340 let encoded_value = outbound_msg.encode();
4341 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4342 assert_eq!(encoded_value, target_value);
4344 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4345 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4346 if let msgs::InboundOnionPayload::Receive {
4347 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4349 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4350 assert_eq!(cltv_expiry_height, 0xffffffff);
4351 } else { panic!(); }
4355 fn encoding_final_onion_hop_data_with_secret() {
4356 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4357 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4358 payment_data: Some(FinalOnionHopData {
4359 payment_secret: expected_payment_secret,
4360 total_msat: 0x1badca1f
4362 payment_metadata: None,
4363 keysend_preimage: None,
4364 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4365 cltv_expiry_height: 0xffffffff,
4366 custom_tlvs: vec![],
4368 let encoded_value = outbound_msg.encode();
4369 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").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::Receive {
4375 payment_data: Some(FinalOnionHopData {
4377 total_msat: 0x1badca1f
4379 sender_intended_htlc_amt_msat, cltv_expiry_height,
4380 payment_metadata: None,
4381 keysend_preimage: None,
4384 assert_eq!(payment_secret, expected_payment_secret);
4385 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4386 assert_eq!(cltv_expiry_height, 0xffffffff);
4387 assert_eq!(custom_tlvs, vec![]);
4388 } else { panic!(); }
4392 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4393 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4395 let bad_type_range_tlvs = vec![
4396 ((1 << 16) - 4, vec![42]),
4397 ((1 << 16) - 2, vec![42; 32]),
4399 let mut msg = msgs::OutboundOnionPayload::Receive {
4401 payment_metadata: None,
4402 keysend_preimage: None,
4403 custom_tlvs: bad_type_range_tlvs,
4404 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4405 cltv_expiry_height: 0xffffffff,
4407 let encoded_value = msg.encode();
4408 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4409 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4410 let good_type_range_tlvs = vec![
4411 ((1 << 16) - 3, vec![42]),
4412 ((1 << 16) - 1, vec![42; 32]),
4414 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4415 *custom_tlvs = good_type_range_tlvs.clone();
4417 let encoded_value = msg.encode();
4418 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4420 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4426 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4427 let expected_custom_tlvs = vec![
4428 (5482373483, vec![0x12, 0x34]),
4429 (5482373487, vec![0x42u8; 8]),
4431 let msg = msgs::OutboundOnionPayload::Receive {
4433 payment_metadata: None,
4434 keysend_preimage: None,
4435 custom_tlvs: expected_custom_tlvs.clone(),
4436 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4437 cltv_expiry_height: 0xffffffff,
4439 let encoded_value = msg.encode();
4440 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4441 assert_eq!(encoded_value, target_value);
4442 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4443 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4444 if let msgs::InboundOnionPayload::Receive {
4446 payment_metadata: None,
4447 keysend_preimage: None,
4449 sender_intended_htlc_amt_msat,
4450 cltv_expiry_height: outgoing_cltv_value,
4453 assert_eq!(custom_tlvs, expected_custom_tlvs);
4454 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4455 assert_eq!(outgoing_cltv_value, 0xffffffff);
4456 } else { panic!(); }
4460 fn encoding_final_onion_hop_data_with_trampoline_packet() {
4461 let secp_ctx = Secp256k1::new();
4462 let (_private_key, public_key) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4464 let compressed_public_key = public_key.serialize();
4465 assert_eq!(compressed_public_key.len(), 33);
4467 let trampoline_packet = TrampolineOnionPacket {
4470 hop_data: vec![1; 650], // this should be the standard encoded length
4473 let encoded_trampoline_packet = trampoline_packet.encode();
4474 assert_eq!(encoded_trampoline_packet.len(), 716);
4476 let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
4477 multipath_trampoline_data: None,
4478 amt_to_forward: 0x0badf00d01020304,
4479 outgoing_cltv_value: 0xffffffff,
4482 let encoded_payload = msg.encode();
4484 let trampoline_type_bytes = &encoded_payload[19..=19];
4485 let mut trampoline_type_cursor = Cursor::new(trampoline_type_bytes);
4486 let trampoline_type_big_size: BigSize = Readable::read(&mut trampoline_type_cursor).unwrap();
4487 assert_eq!(trampoline_type_big_size.0, 20);
4489 let trampoline_length_bytes = &encoded_payload[20..=22];
4490 let mut trampoline_length_cursor = Cursor::new(trampoline_length_bytes);
4491 let trampoline_length_big_size: BigSize = Readable::read(&mut trampoline_length_cursor).unwrap();
4492 assert_eq!(trampoline_length_big_size.0, encoded_trampoline_packet.len() as u64);
4496 fn encoding_final_onion_hop_data_with_eclair_trampoline_packet() {
4497 let public_key = PublicKey::from_slice(&<Vec<u8>>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()).unwrap();
4498 let hop_data = <Vec<u8>>::from_hex("cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4c").unwrap();
4499 let hmac_vector = <Vec<u8>>::from_hex("bb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4500 let mut hmac = [0; 32];
4501 hmac.copy_from_slice(&hmac_vector);
4503 let compressed_public_key = public_key.serialize();
4504 assert_eq!(compressed_public_key.len(), 33);
4506 let trampoline_packet = TrampolineOnionPacket {
4512 let encoded_trampoline_packet = trampoline_packet.encode();
4513 let expected_eclair_trampoline_packet = <Vec<u8>>::from_hex("0002eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4cbb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4514 assert_eq!(encoded_trampoline_packet, expected_eclair_trampoline_packet);
4518 fn query_channel_range_end_blocknum() {
4519 let tests: Vec<(u32, u32, u32)> = vec![
4520 (10000, 1500, 11500),
4521 (0, 0xffffffff, 0xffffffff),
4522 (1, 0xffffffff, 0xffffffff),
4525 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4526 let sut = msgs::QueryChannelRange {
4527 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4531 assert_eq!(sut.end_blocknum(), expected);
4536 fn encoding_query_channel_range() {
4537 let mut query_channel_range = msgs::QueryChannelRange {
4538 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4539 first_blocknum: 100000,
4540 number_of_blocks: 1500,
4542 let encoded_value = query_channel_range.encode();
4543 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4544 assert_eq!(encoded_value, target_value);
4546 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4547 assert_eq!(query_channel_range.first_blocknum, 100000);
4548 assert_eq!(query_channel_range.number_of_blocks, 1500);
4552 fn encoding_reply_channel_range() {
4553 do_encoding_reply_channel_range(0);
4554 do_encoding_reply_channel_range(1);
4557 fn do_encoding_reply_channel_range(encoding_type: u8) {
4558 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4559 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4560 let mut reply_channel_range = msgs::ReplyChannelRange {
4561 chain_hash: expected_chain_hash,
4562 first_blocknum: 756230,
4563 number_of_blocks: 1500,
4564 sync_complete: true,
4565 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4568 if encoding_type == 0 {
4569 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4570 let encoded_value = reply_channel_range.encode();
4571 assert_eq!(encoded_value, target_value);
4573 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4574 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4575 assert_eq!(reply_channel_range.first_blocknum, 756230);
4576 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4577 assert_eq!(reply_channel_range.sync_complete, true);
4578 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4579 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4580 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4582 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4583 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4584 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4589 fn encoding_query_short_channel_ids() {
4590 do_encoding_query_short_channel_ids(0);
4591 do_encoding_query_short_channel_ids(1);
4594 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4595 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4596 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4597 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4598 chain_hash: expected_chain_hash,
4599 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4602 if encoding_type == 0 {
4603 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4604 let encoded_value = query_short_channel_ids.encode();
4605 assert_eq!(encoded_value, target_value);
4607 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4608 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4609 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4610 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4611 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4613 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4614 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4615 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4620 fn encoding_reply_short_channel_ids_end() {
4621 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4622 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4623 chain_hash: expected_chain_hash,
4624 full_information: true,
4626 let encoded_value = reply_short_channel_ids_end.encode();
4627 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4628 assert_eq!(encoded_value, target_value);
4630 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4631 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4632 assert_eq!(reply_short_channel_ids_end.full_information, true);
4636 fn encoding_gossip_timestamp_filter(){
4637 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4638 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4639 chain_hash: expected_chain_hash,
4640 first_timestamp: 1590000000,
4641 timestamp_range: 0xffff_ffff,
4643 let encoded_value = gossip_timestamp_filter.encode();
4644 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4645 assert_eq!(encoded_value, target_value);
4647 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4648 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4649 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4650 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4654 fn decode_onion_hop_data_len_as_bigsize() {
4655 // Tests that we can decode an onion payload that is >253 bytes.
4656 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4657 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4660 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4661 // payload length to be encoded over multiple bytes rather than a single u8.
4662 let big_payload = encode_big_payload().unwrap();
4663 let mut rd = Cursor::new(&big_payload[..]);
4665 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4666 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4667 ::read(&mut rd, (None, &&node_signer)).unwrap();
4669 // see above test, needs to be a separate method for use of the serialization macros.
4670 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4671 use crate::util::ser::HighZeroBytesDroppedBigSize;
4672 let payload = msgs::OutboundOnionPayload::Forward {
4673 short_channel_id: 0xdeadbeef1bad1dea,
4674 amt_to_forward: 1000,
4675 outgoing_cltv_value: 0xffffffff,
4677 let mut encoded_payload = Vec::new();
4678 let test_bytes = vec![42u8; 1000];
4679 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4680 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4681 (1, test_bytes, required_vec),
4682 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4683 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4684 (6, short_channel_id, required)
4691 #[cfg(feature = "std")]
4692 fn test_socket_address_from_str() {
4693 let tcpip_v4 = SocketAddress::TcpIpV4 {
4694 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4697 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4698 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4700 let tcpip_v6 = SocketAddress::TcpIpV6 {
4701 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4704 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4705 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4707 let hostname = SocketAddress::Hostname {
4708 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4711 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4712 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4714 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4715 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4716 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4718 let onion_v3 = SocketAddress::OnionV3 {
4719 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4720 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4725 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4726 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4728 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4729 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4730 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4731 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4732 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4733 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4734 assert!("localhost".parse::<SocketAddress>().is_err());
4735 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4736 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4737 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4738 assert!("invalid-address".parse::<SocketAddress>().is_err());
4739 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4743 #[cfg(feature = "std")]
4744 fn test_socket_address_to_socket_addrs() {
4745 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4746 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4747 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4748 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4749 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4750 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4751 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4752 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4753 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4757 port: 1234 }.to_socket_addrs().is_err());