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,
96 /// An [`init`] message to be sent to or received from a peer.
98 /// [`init`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-init-message
99 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
101 /// The relevant features which the sender supports.
102 pub features: InitFeatures,
103 /// Indicates chains the sender is interested in.
105 /// If there are no common chains, the connection will be closed.
106 pub networks: Option<Vec<ChainHash>>,
107 /// The receipient's network address.
109 /// This adds the option to report a remote IP address back to a connecting peer using the init
110 /// message. A node can decide to use that information to discover a potential update to its
111 /// public IPv4 address (NAT) and use that for a [`NodeAnnouncement`] update message containing
113 pub remote_network_address: Option<SocketAddress>,
116 /// An [`error`] message to be sent to or received from a peer.
118 /// [`error`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
119 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
120 pub struct ErrorMessage {
121 /// The channel ID involved in the error.
123 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
124 /// with the sending peer should be closed.
125 pub channel_id: ChannelId,
126 /// A possibly human-readable error description.
128 /// The string should be sanitized before it is used (e.g., emitted to logs or printed to
129 /// `stdout`). Otherwise, a well crafted error message may trigger a security vulnerability in
130 /// the terminal emulator or the logging subsystem.
134 /// A [`warning`] message to be sent to or received from a peer.
136 /// [`warning`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-error-and-warning-messages
137 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
138 pub struct WarningMessage {
139 /// The channel ID involved in the warning.
141 /// All-0s indicates a warning unrelated to a specific channel.
142 pub channel_id: ChannelId,
143 /// A possibly human-readable warning description.
145 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
146 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
147 /// the terminal emulator or the logging subsystem.
151 /// A [`ping`] message to be sent to or received from a peer.
153 /// [`ping`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
154 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
156 /// The desired response length.
158 /// The ping packet size.
160 /// This field is not sent on the wire. byteslen zeros are sent.
164 /// A [`pong`] message to be sent to or received from a peer.
166 /// [`pong`]: https://github.com/lightning/bolts/blob/master/01-messaging.md#the-ping-and-pong-messages
167 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
169 /// The pong packet size.
171 /// This field is not sent on the wire. byteslen zeros are sent.
175 /// Contains fields that are both common to [`open_channel`] and `open_channel2` messages.
177 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
178 // TODO(dual_funding): Add spec link for `open_channel2`.
179 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
180 pub struct CommonOpenChannelFields {
181 /// The genesis hash of the blockchain where the channel is to be opened
182 pub chain_hash: ChainHash,
183 /// A temporary channel ID
184 /// For V2 channels: derived using a zeroed out value for the channel acceptor's revocation basepoint
185 /// For V1 channels: a temporary channel ID, until the funding outpoint is announced
186 pub temporary_channel_id: ChannelId,
187 /// For V1 channels: The channel value
188 /// For V2 channels: Part of the channel value contributed by the channel initiator
189 pub funding_satoshis: u64,
190 /// The threshold below which outputs on transactions broadcast by the channel initiator will be
192 pub dust_limit_satoshis: u64,
193 /// The maximum inbound HTLC value in flight towards channel initiator, in milli-satoshi
194 pub max_htlc_value_in_flight_msat: u64,
195 /// The minimum HTLC size incoming to channel initiator, in milli-satoshi
196 pub htlc_minimum_msat: u64,
197 /// The feerate for the commitment transaction set by the channel initiator until updated by
199 pub commitment_feerate_sat_per_1000_weight: u32,
200 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
201 /// broadcast a commitment transaction
202 pub to_self_delay: u16,
203 /// The maximum number of inbound HTLCs towards channel initiator
204 pub max_accepted_htlcs: u16,
205 /// The channel initiator's key controlling the funding transaction
206 pub funding_pubkey: PublicKey,
207 /// Used to derive a revocation key for transactions broadcast by counterparty
208 pub revocation_basepoint: PublicKey,
209 /// A payment key to channel initiator for transactions broadcast by counterparty
210 pub payment_basepoint: PublicKey,
211 /// Used to derive a payment key to channel initiator for transactions broadcast by channel
213 pub delayed_payment_basepoint: PublicKey,
214 /// Used to derive an HTLC payment key to channel initiator
215 pub htlc_basepoint: PublicKey,
216 /// The first to-be-broadcast-by-channel-initiator transaction's per commitment point
217 pub first_per_commitment_point: PublicKey,
218 /// The channel flags to be used
219 pub channel_flags: u8,
220 /// Optionally, a request to pre-set the to-channel-initiator output's scriptPubkey for when we
221 /// collaboratively close
222 pub shutdown_scriptpubkey: Option<ScriptBuf>,
223 /// The channel type that this channel will represent
225 /// If this is `None`, we derive the channel type from the intersection of our
226 /// feature bits with our counterparty's feature bits from the [`Init`] message.
227 pub channel_type: Option<ChannelTypeFeatures>,
230 /// An [`open_channel`] message to be sent to or received from a peer.
232 /// Used in V1 channel establishment
234 /// [`open_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message
235 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
236 pub struct OpenChannel {
237 /// Common fields of `open_channel(2)`-like messages
238 pub common_fields: CommonOpenChannelFields,
239 /// The amount to push to the counterparty as part of the open, in milli-satoshi
241 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
242 pub channel_reserve_satoshis: u64,
245 /// An open_channel2 message to be sent by or received from the channel initiator.
247 /// Used in V2 channel establishment
249 // TODO(dual_funding): Add spec link for `open_channel2`.
250 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
251 pub struct OpenChannelV2 {
252 /// Common fields of `open_channel(2)`-like messages
253 pub common_fields: CommonOpenChannelFields,
254 /// The feerate for the funding transaction set by the channel initiator
255 pub funding_feerate_sat_per_1000_weight: u32,
256 /// The locktime for the funding transaction
258 /// The second to-be-broadcast-by-channel-initiator transaction's per commitment point
259 pub second_per_commitment_point: PublicKey,
260 /// Optionally, a requirement that only confirmed inputs can be added
261 pub require_confirmed_inputs: Option<()>,
264 /// Contains fields that are both common to [`accept_channel`] and `accept_channel2` messages.
266 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
267 // TODO(dual_funding): Add spec link for `accept_channel2`.
268 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
269 pub struct CommonAcceptChannelFields {
270 /// The same `temporary_channel_id` received from the initiator's `open_channel2` or `open_channel` message.
271 pub temporary_channel_id: ChannelId,
272 /// The threshold below which outputs on transactions broadcast by the channel acceptor will be
274 pub dust_limit_satoshis: u64,
275 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
276 pub max_htlc_value_in_flight_msat: u64,
277 /// The minimum HTLC size incoming to channel acceptor, in milli-satoshi
278 pub htlc_minimum_msat: u64,
279 /// Minimum depth of the funding transaction before the channel is considered open
280 pub minimum_depth: u32,
281 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they
282 /// broadcast a commitment transaction
283 pub to_self_delay: u16,
284 /// The maximum number of inbound HTLCs towards channel acceptor
285 pub max_accepted_htlcs: u16,
286 /// The channel acceptor's key controlling the funding transaction
287 pub funding_pubkey: PublicKey,
288 /// Used to derive a revocation key for transactions broadcast by counterparty
289 pub revocation_basepoint: PublicKey,
290 /// A payment key to channel acceptor for transactions broadcast by counterparty
291 pub payment_basepoint: PublicKey,
292 /// Used to derive a payment key to channel acceptor for transactions broadcast by channel
294 pub delayed_payment_basepoint: PublicKey,
295 /// Used to derive an HTLC payment key to channel acceptor for transactions broadcast by counterparty
296 pub htlc_basepoint: PublicKey,
297 /// The first to-be-broadcast-by-channel-acceptor transaction's per commitment point
298 pub first_per_commitment_point: PublicKey,
299 /// Optionally, a request to pre-set the to-channel-acceptor output's scriptPubkey for when we
300 /// collaboratively close
301 pub shutdown_scriptpubkey: Option<ScriptBuf>,
302 /// The channel type that this channel will represent. If none is set, we derive the channel
303 /// type from the intersection of our feature bits with our counterparty's feature bits from
304 /// the Init message.
306 /// This is required to match the equivalent field in [`OpenChannel`] or [`OpenChannelV2`]'s
307 /// [`CommonOpenChannelFields::channel_type`].
308 pub channel_type: Option<ChannelTypeFeatures>,
311 /// An [`accept_channel`] message to be sent to or received from a peer.
313 /// Used in V1 channel establishment
315 /// [`accept_channel`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-accept_channel-message
316 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
317 pub struct AcceptChannel {
318 /// Common fields of `accept_channel(2)`-like messages
319 pub common_fields: CommonAcceptChannelFields,
320 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
321 pub channel_reserve_satoshis: u64,
323 /// Next nonce the channel initiator should use to create a funding output signature against
324 pub next_local_nonce: Option<musig2::types::PublicNonce>,
327 /// An accept_channel2 message to be sent by or received from the channel accepter.
329 /// Used in V2 channel establishment
331 // TODO(dual_funding): Add spec link for `accept_channel2`.
332 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
333 pub struct AcceptChannelV2 {
334 /// Common fields of `accept_channel(2)`-like messages
335 pub common_fields: CommonAcceptChannelFields,
336 /// Part of the channel value contributed by the channel acceptor
337 pub funding_satoshis: u64,
338 /// The second to-be-broadcast-by-channel-acceptor transaction's per commitment point
339 pub second_per_commitment_point: PublicKey,
340 /// Optionally, a requirement that only confirmed inputs can be added
341 pub require_confirmed_inputs: Option<()>,
344 /// A [`funding_created`] message to be sent to or received from a peer.
346 /// Used in V1 channel establishment
348 /// [`funding_created`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_created-message
349 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
350 pub struct FundingCreated {
351 /// A temporary channel ID, until the funding is established
352 pub temporary_channel_id: ChannelId,
353 /// The funding transaction ID
354 pub funding_txid: Txid,
355 /// The specific output index funding this channel
356 pub funding_output_index: u16,
357 /// The signature of the channel initiator (funder) on the initial commitment transaction
358 pub signature: Signature,
360 /// The partial signature of the channel initiator (funder)
361 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
363 /// Next nonce the channel acceptor should use to finalize the funding output signature
364 pub next_local_nonce: Option<musig2::types::PublicNonce>
367 /// A [`funding_signed`] message to be sent to or received from a peer.
369 /// Used in V1 channel establishment
371 /// [`funding_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-funding_signed-message
372 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
373 pub struct FundingSigned {
375 pub channel_id: ChannelId,
376 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
377 pub signature: Signature,
379 /// The partial signature of the channel acceptor (fundee)
380 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
383 /// A [`channel_ready`] message to be sent to or received from a peer.
385 /// [`channel_ready`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-channel_ready-message
386 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
387 pub struct ChannelReady {
389 pub channel_id: ChannelId,
390 /// The per-commitment point of the second commitment transaction
391 pub next_per_commitment_point: PublicKey,
392 /// If set, provides a `short_channel_id` alias for this channel.
394 /// The sender will accept payments to be forwarded over this SCID and forward them to this
395 /// messages' recipient.
396 pub short_channel_id_alias: Option<u64>,
399 /// A randomly chosen number that is used to identify inputs within an interactive transaction
401 pub type SerialId = u64;
403 /// An stfu (quiescence) message to be sent by or received from the stfu initiator.
404 // TODO(splicing): Add spec link for `stfu`; still in draft, using from https://github.com/lightning/bolts/pull/863
405 #[derive(Clone, Debug, PartialEq, Eq)]
407 /// The channel ID where quiescence is intended
408 pub channel_id: ChannelId,
409 /// Initiator flag, 1 if initiating, 0 if replying to an stfu.
413 /// A splice message to be sent by or received from the stfu initiator (splice initiator).
414 // TODO(splicing): Add spec link for `splice`; still in draft, using from https://github.com/lightning/bolts/pull/863
415 #[derive(Clone, Debug, PartialEq, Eq)]
417 /// The channel ID where splicing is intended
418 pub channel_id: ChannelId,
419 /// The genesis hash of the blockchain where the channel is intended to be spliced
420 pub chain_hash: ChainHash,
421 /// The intended change in channel capacity: the amount to be added (positive value)
422 /// or removed (negative value) by the sender (splice initiator) by splicing into/from the channel.
423 pub relative_satoshis: i64,
424 /// The feerate for the new funding transaction, set by the splice initiator
425 pub funding_feerate_perkw: u32,
426 /// The locktime for the new funding transaction
428 /// The key of the sender (splice initiator) controlling the new funding transaction
429 pub funding_pubkey: PublicKey,
432 /// A splice_ack message to be received by or sent to the splice initiator.
434 // TODO(splicing): Add spec link for `splice_ack`; still in draft, using from https://github.com/lightning/bolts/pull/863
435 #[derive(Clone, Debug, PartialEq, Eq)]
436 pub struct SpliceAck {
437 /// The channel ID where splicing is intended
438 pub channel_id: ChannelId,
439 /// The genesis hash of the blockchain where the channel is intended to be spliced
440 pub chain_hash: ChainHash,
441 /// The intended change in channel capacity: the amount to be added (positive value)
442 /// or removed (negative value) by the sender (splice acceptor) by splicing into/from the channel.
443 pub relative_satoshis: i64,
444 /// The key of the sender (splice acceptor) controlling the new funding transaction
445 pub funding_pubkey: PublicKey,
448 /// A splice_locked message to be sent to or received from a peer.
450 // TODO(splicing): Add spec link for `splice_locked`; still in draft, using from https://github.com/lightning/bolts/pull/863
451 #[derive(Clone, Debug, PartialEq, Eq)]
452 pub struct SpliceLocked {
454 pub channel_id: ChannelId,
457 /// A tx_add_input message for adding an input during interactive transaction construction
459 // TODO(dual_funding): Add spec link for `tx_add_input`.
460 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
461 pub struct TxAddInput {
463 pub channel_id: ChannelId,
464 /// A randomly chosen unique identifier for this input, which is even for initiators and odd for
466 pub serial_id: SerialId,
467 /// Serialized transaction that contains the output this input spends to verify that it is non
469 pub prevtx: TransactionU16LenLimited,
470 /// The index of the output being spent
472 /// The sequence number of this input
476 /// A tx_add_output message for adding an output during interactive transaction construction.
478 // TODO(dual_funding): Add spec link for `tx_add_output`.
479 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
480 pub struct TxAddOutput {
482 pub channel_id: ChannelId,
483 /// A randomly chosen unique identifier for this output, which is even for initiators and odd for
485 pub serial_id: SerialId,
486 /// The satoshi value of the output
488 /// The scriptPubKey for the output
489 pub script: ScriptBuf,
492 /// A tx_remove_input message for removing an input during interactive transaction construction.
494 // TODO(dual_funding): Add spec link for `tx_remove_input`.
495 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
496 pub struct TxRemoveInput {
498 pub channel_id: ChannelId,
499 /// The serial ID of the input to be removed
500 pub serial_id: SerialId,
503 /// A tx_remove_output message for removing an output during interactive transaction construction.
505 // TODO(dual_funding): Add spec link for `tx_remove_output`.
506 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
507 pub struct TxRemoveOutput {
509 pub channel_id: ChannelId,
510 /// The serial ID of the output to be removed
511 pub serial_id: SerialId,
514 /// A tx_complete message signalling the conclusion of a peer's transaction contributions during
515 /// interactive transaction construction.
517 // TODO(dual_funding): Add spec link for `tx_complete`.
518 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
519 pub struct TxComplete {
521 pub channel_id: ChannelId,
524 /// A tx_signatures message containing the sender's signatures for a transaction constructed with
525 /// interactive transaction construction.
527 // TODO(dual_funding): Add spec link for `tx_signatures`.
528 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
529 pub struct TxSignatures {
531 pub channel_id: ChannelId,
534 /// The list of witnesses
535 pub witnesses: Vec<Witness>,
538 /// A tx_init_rbf message which initiates a replacement of the transaction after it's been
541 // TODO(dual_funding): Add spec link for `tx_init_rbf`.
542 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
543 pub struct TxInitRbf {
545 pub channel_id: ChannelId,
546 /// The locktime of the transaction
548 /// The feerate of the transaction
549 pub feerate_sat_per_1000_weight: u32,
550 /// The number of satoshis the sender will contribute to or, if negative, remove from
551 /// (e.g. splice-out) the funding output of the transaction
552 pub funding_output_contribution: Option<i64>,
555 /// A tx_ack_rbf message which acknowledges replacement of the transaction after it's been
558 // TODO(dual_funding): Add spec link for `tx_ack_rbf`.
559 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
560 pub struct TxAckRbf {
562 pub channel_id: ChannelId,
563 /// The number of satoshis the sender will contribute to or, if negative, remove from
564 /// (e.g. splice-out) the funding output of the transaction
565 pub funding_output_contribution: Option<i64>,
568 /// A tx_abort message which signals the cancellation of an in-progress transaction negotiation.
570 // TODO(dual_funding): Add spec link for `tx_abort`.
571 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
574 pub channel_id: ChannelId,
579 /// A [`shutdown`] message to be sent to or received from a peer.
581 /// [`shutdown`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-initiation-shutdown
582 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
583 pub struct Shutdown {
585 pub channel_id: ChannelId,
586 /// The destination of this peer's funds on closing.
588 /// Must be in one of these forms: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.
589 pub scriptpubkey: ScriptBuf,
592 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
594 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
596 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
597 pub struct ClosingSignedFeeRange {
598 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
600 pub min_fee_satoshis: u64,
601 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
603 pub max_fee_satoshis: u64,
606 /// A [`closing_signed`] message to be sent to or received from a peer.
608 /// [`closing_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#closing-negotiation-closing_signed
609 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
610 pub struct ClosingSigned {
612 pub channel_id: ChannelId,
613 /// The proposed total fee for the closing transaction
614 pub fee_satoshis: u64,
615 /// A signature on the closing transaction
616 pub signature: Signature,
617 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
619 pub fee_range: Option<ClosingSignedFeeRange>,
622 /// An [`update_add_htlc`] message to be sent to or received from a peer.
624 /// [`update_add_htlc`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#adding-an-htlc-update_add_htlc
625 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
626 pub struct UpdateAddHTLC {
628 pub channel_id: ChannelId,
631 /// The HTLC value in milli-satoshi
632 pub amount_msat: u64,
633 /// The payment hash, the pre-image of which controls HTLC redemption
634 pub payment_hash: PaymentHash,
635 /// The expiry height of the HTLC
636 pub cltv_expiry: u32,
637 /// The extra fee skimmed by the sender of this message. See
638 /// [`ChannelConfig::accept_underpaying_htlcs`].
640 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
641 pub skimmed_fee_msat: Option<u64>,
642 /// The onion routing packet with encrypted data for the next hop.
643 pub onion_routing_packet: OnionPacket,
644 /// Provided if we are relaying or receiving a payment within a blinded path, to decrypt the onion
645 /// routing packet and the recipient-provided encrypted payload within.
646 pub blinding_point: Option<PublicKey>,
649 /// An onion message to be sent to or received from a peer.
651 // TODO: update with link to OM when they are merged into the BOLTs
652 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
653 pub struct OnionMessage {
654 /// Used in decrypting the onion packet's payload.
655 pub blinding_point: PublicKey,
656 /// The full onion packet including hop data, pubkey, and hmac
657 pub onion_routing_packet: onion_message::packet::Packet,
660 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.
662 /// [`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
663 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
664 pub struct UpdateFulfillHTLC {
666 pub channel_id: ChannelId,
669 /// The pre-image of the payment hash, allowing HTLC redemption
670 pub payment_preimage: PaymentPreimage,
673 /// An [`update_fail_htlc`] message to be sent to or received from a peer.
675 /// [`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
676 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
677 pub struct UpdateFailHTLC {
679 pub channel_id: ChannelId,
682 pub(crate) reason: OnionErrorPacket,
685 /// An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
687 /// [`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
688 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
689 pub struct UpdateFailMalformedHTLC {
691 pub channel_id: ChannelId,
694 pub(crate) sha256_of_onion: [u8; 32],
696 pub failure_code: u16,
699 /// A [`commitment_signed`] message to be sent to or received from a peer.
701 /// [`commitment_signed`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#committing-updates-so-far-commitment_signed
702 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
703 pub struct CommitmentSigned {
705 pub channel_id: ChannelId,
706 /// A signature on the commitment transaction
707 pub signature: Signature,
708 /// Signatures on the HTLC transactions
709 pub htlc_signatures: Vec<Signature>,
711 /// The partial Taproot signature on the commitment transaction
712 pub partial_signature_with_nonce: Option<PartialSignatureWithNonce>,
715 /// A [`revoke_and_ack`] message to be sent to or received from a peer.
717 /// [`revoke_and_ack`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#completing-the-transition-to-the-updated-state-revoke_and_ack
718 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
719 pub struct RevokeAndACK {
721 pub channel_id: ChannelId,
722 /// The secret corresponding to the per-commitment point
723 pub per_commitment_secret: [u8; 32],
724 /// The next sender-broadcast commitment transaction's per-commitment point
725 pub next_per_commitment_point: PublicKey,
727 /// Musig nonce the recipient should use in their next commitment signature message
728 pub next_local_nonce: Option<musig2::types::PublicNonce>
731 /// An [`update_fee`] message to be sent to or received from a peer
733 /// [`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
734 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
735 pub struct UpdateFee {
737 pub channel_id: ChannelId,
738 /// Fee rate per 1000-weight of the transaction
739 pub feerate_per_kw: u32,
742 /// A [`channel_reestablish`] message to be sent to or received from a peer.
744 /// [`channel_reestablish`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#message-retransmission
745 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
746 pub struct ChannelReestablish {
748 pub channel_id: ChannelId,
749 /// The next commitment number for the sender
750 pub next_local_commitment_number: u64,
751 /// The next commitment number for the recipient
752 pub next_remote_commitment_number: u64,
753 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
754 /// belonging to the recipient
755 pub your_last_per_commitment_secret: [u8; 32],
756 /// The sender's per-commitment point for their current commitment transaction
757 pub my_current_per_commitment_point: PublicKey,
758 /// The next funding transaction ID
759 pub next_funding_txid: Option<Txid>,
762 /// An [`announcement_signatures`] message to be sent to or received from a peer.
764 /// [`announcement_signatures`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-announcement_signatures-message
765 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
766 pub struct AnnouncementSignatures {
768 pub channel_id: ChannelId,
769 /// The short channel ID
770 pub short_channel_id: u64,
771 /// A signature by the node key
772 pub node_signature: Signature,
773 /// A signature by the funding key
774 pub bitcoin_signature: Signature,
777 /// An address which can be used to connect to a remote peer.
778 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
779 pub enum SocketAddress {
780 /// An IPv4 address and port on which the peer is listening.
782 /// The 4-byte IPv4 address
784 /// The port on which the node is listening
787 /// An IPv6 address and port on which the peer is listening.
789 /// The 16-byte IPv6 address
791 /// The port on which the node is listening
794 /// An old-style Tor onion address/port on which the peer is listening.
796 /// This field is deprecated and the Tor network generally no longer supports V2 Onion
797 /// addresses. Thus, the details are not parsed here.
799 /// A new-style Tor onion address/port on which the peer is listening.
801 /// To create the human-readable "hostname", concatenate the ED25519 pubkey, checksum, and version,
802 /// wrap as base32 and append ".onion".
804 /// The ed25519 long-term public key of the peer
805 ed25519_pubkey: [u8; 32],
806 /// The checksum of the pubkey and version, as included in the onion address
808 /// The version byte, as defined by the Tor Onion v3 spec.
810 /// The port on which the node is listening
813 /// A hostname/port on which the peer is listening.
815 /// The hostname on which the node is listening.
817 /// The port on which the node is listening.
822 /// Gets the ID of this address type. Addresses in [`NodeAnnouncement`] messages should be sorted
824 pub(crate) fn get_id(&self) -> u8 {
826 &SocketAddress::TcpIpV4 {..} => { 1 },
827 &SocketAddress::TcpIpV6 {..} => { 2 },
828 &SocketAddress::OnionV2(_) => { 3 },
829 &SocketAddress::OnionV3 {..} => { 4 },
830 &SocketAddress::Hostname {..} => { 5 },
834 /// Strict byte-length of address descriptor, 1-byte type not recorded
835 fn len(&self) -> u16 {
837 &SocketAddress::TcpIpV4 { .. } => { 6 },
838 &SocketAddress::TcpIpV6 { .. } => { 18 },
839 &SocketAddress::OnionV2(_) => { 12 },
840 &SocketAddress::OnionV3 { .. } => { 37 },
841 // Consists of 1-byte hostname length, hostname bytes, and 2-byte port.
842 &SocketAddress::Hostname { ref hostname, .. } => { u16::from(hostname.len()) + 3 },
846 /// The maximum length of any address descriptor, not including the 1-byte type.
847 /// This maximum length is reached by a hostname address descriptor:
848 /// a hostname with a maximum length of 255, its 1-byte length and a 2-byte port.
849 pub(crate) const MAX_LEN: u16 = 258;
851 pub(crate) fn is_tor(&self) -> bool {
853 &SocketAddress::TcpIpV4 {..} => false,
854 &SocketAddress::TcpIpV6 {..} => false,
855 &SocketAddress::OnionV2(_) => true,
856 &SocketAddress::OnionV3 {..} => true,
857 &SocketAddress::Hostname {..} => false,
862 impl Writeable for SocketAddress {
863 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
865 &SocketAddress::TcpIpV4 { ref addr, ref port } => {
870 &SocketAddress::TcpIpV6 { ref addr, ref port } => {
875 &SocketAddress::OnionV2(bytes) => {
877 bytes.write(writer)?;
879 &SocketAddress::OnionV3 { ref ed25519_pubkey, ref checksum, ref version, ref port } => {
881 ed25519_pubkey.write(writer)?;
882 checksum.write(writer)?;
883 version.write(writer)?;
886 &SocketAddress::Hostname { ref hostname, ref port } => {
888 hostname.write(writer)?;
896 impl Readable for Result<SocketAddress, u8> {
897 fn read<R: Read>(reader: &mut R) -> Result<Result<SocketAddress, u8>, DecodeError> {
898 let byte = <u8 as Readable>::read(reader)?;
901 Ok(Ok(SocketAddress::TcpIpV4 {
902 addr: Readable::read(reader)?,
903 port: Readable::read(reader)?,
907 Ok(Ok(SocketAddress::TcpIpV6 {
908 addr: Readable::read(reader)?,
909 port: Readable::read(reader)?,
912 3 => Ok(Ok(SocketAddress::OnionV2(Readable::read(reader)?))),
914 Ok(Ok(SocketAddress::OnionV3 {
915 ed25519_pubkey: Readable::read(reader)?,
916 checksum: Readable::read(reader)?,
917 version: Readable::read(reader)?,
918 port: Readable::read(reader)?,
922 Ok(Ok(SocketAddress::Hostname {
923 hostname: Readable::read(reader)?,
924 port: Readable::read(reader)?,
927 _ => return Ok(Err(byte)),
932 impl Readable for SocketAddress {
933 fn read<R: Read>(reader: &mut R) -> Result<SocketAddress, DecodeError> {
934 match Readable::read(reader) {
935 Ok(Ok(res)) => Ok(res),
936 Ok(Err(_)) => Err(DecodeError::UnknownVersion),
942 /// [`SocketAddress`] error variants
943 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
944 pub enum SocketAddressParseError {
945 /// Socket address (IPv4/IPv6) parsing error
947 /// Invalid input format
951 /// Invalid onion v3 address
955 impl fmt::Display for SocketAddressParseError {
956 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
958 SocketAddressParseError::SocketAddrParse => write!(f, "Socket address (IPv4/IPv6) parsing error"),
959 SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
960 Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
961 SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
962 SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
967 #[cfg(feature = "std")]
968 impl From<std::net::SocketAddrV4> for SocketAddress {
969 fn from(addr: std::net::SocketAddrV4) -> Self {
970 SocketAddress::TcpIpV4 { addr: addr.ip().octets(), port: addr.port() }
974 #[cfg(feature = "std")]
975 impl From<std::net::SocketAddrV6> for SocketAddress {
976 fn from(addr: std::net::SocketAddrV6) -> Self {
977 SocketAddress::TcpIpV6 { addr: addr.ip().octets(), port: addr.port() }
981 #[cfg(feature = "std")]
982 impl From<std::net::SocketAddr> for SocketAddress {
983 fn from(addr: std::net::SocketAddr) -> Self {
985 std::net::SocketAddr::V4(addr) => addr.into(),
986 std::net::SocketAddr::V6(addr) => addr.into(),
991 #[cfg(feature = "std")]
992 impl std::net::ToSocketAddrs for SocketAddress {
993 type Iter = std::vec::IntoIter<std::net::SocketAddr>;
995 fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
997 SocketAddress::TcpIpV4 { addr, port } => {
998 let ip_addr = std::net::Ipv4Addr::from(*addr);
999 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1000 Ok(vec![socket_addr].into_iter())
1002 SocketAddress::TcpIpV6 { addr, port } => {
1003 let ip_addr = std::net::Ipv6Addr::from(*addr);
1004 let socket_addr = SocketAddr::new(ip_addr.into(), *port);
1005 Ok(vec![socket_addr].into_iter())
1007 SocketAddress::Hostname { ref hostname, port } => {
1008 (hostname.as_str(), *port).to_socket_addrs()
1010 SocketAddress::OnionV2(..) => {
1011 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV2 \
1012 addresses is currently unsupported."))
1014 SocketAddress::OnionV3 { .. } => {
1015 Err(std::io::Error::new(std::io::ErrorKind::Other, "Resolution of OnionV3 \
1016 addresses is currently unsupported."))
1022 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
1024 /// The host part must end with ".onion".
1025 pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
1026 if host.ends_with(".onion") {
1027 let domain = &host[..host.len() - ".onion".len()];
1028 if domain.len() != 56 {
1029 return Err(SocketAddressParseError::InvalidOnionV3);
1031 let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
1032 if onion.len() != 35 {
1033 return Err(SocketAddressParseError::InvalidOnionV3);
1035 let version = onion[0];
1036 let first_checksum_flag = onion[1];
1037 let second_checksum_flag = onion[2];
1038 let mut ed25519_pubkey = [0; 32];
1039 ed25519_pubkey.copy_from_slice(&onion[3..35]);
1040 let checksum = u16::from_be_bytes([first_checksum_flag, second_checksum_flag]);
1041 return Ok(SocketAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
1044 return Err(SocketAddressParseError::InvalidInput);
1048 impl Display for SocketAddress {
1049 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1051 SocketAddress::TcpIpV4{addr, port} => write!(
1052 f, "{}.{}.{}.{}:{}", addr[0], addr[1], addr[2], addr[3], port)?,
1053 SocketAddress::TcpIpV6{addr, port} => write!(
1055 "[{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}]:{}",
1056 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
1058 SocketAddress::OnionV2(bytes) => write!(f, "OnionV2({:?})", bytes)?,
1059 SocketAddress::OnionV3 {
1065 let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
1066 let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
1067 addr.extend_from_slice(ed25519_pubkey);
1068 let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
1069 write!(f, "{}.onion:{}", onion, port)?
1071 SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
1077 #[cfg(feature = "std")]
1078 impl FromStr for SocketAddress {
1079 type Err = SocketAddressParseError;
1081 fn from_str(s: &str) -> Result<Self, Self::Err> {
1082 match std::net::SocketAddr::from_str(s) {
1083 Ok(addr) => Ok(addr.into()),
1085 let trimmed_input = match s.rfind(":") {
1087 None => return Err(SocketAddressParseError::InvalidInput),
1089 let host = &s[..trimmed_input];
1090 let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
1091 if host.ends_with(".onion") {
1092 return parse_onion_address(host, port);
1094 if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
1095 return Ok(SocketAddress::Hostname { hostname, port });
1097 return Err(SocketAddressParseError::SocketAddrParse)
1103 /// Represents the set of gossip messages that require a signature from a node's identity key.
1104 pub enum UnsignedGossipMessage<'a> {
1105 /// An unsigned channel announcement.
1106 ChannelAnnouncement(&'a UnsignedChannelAnnouncement),
1107 /// An unsigned channel update.
1108 ChannelUpdate(&'a UnsignedChannelUpdate),
1109 /// An unsigned node announcement.
1110 NodeAnnouncement(&'a UnsignedNodeAnnouncement)
1113 impl<'a> Writeable for UnsignedGossipMessage<'a> {
1114 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
1116 UnsignedGossipMessage::ChannelAnnouncement(ref msg) => msg.write(writer),
1117 UnsignedGossipMessage::ChannelUpdate(ref msg) => msg.write(writer),
1118 UnsignedGossipMessage::NodeAnnouncement(ref msg) => msg.write(writer),
1123 /// The unsigned part of a [`node_announcement`] message.
1125 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1126 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1127 pub struct UnsignedNodeAnnouncement {
1128 /// The advertised features
1129 pub features: NodeFeatures,
1130 /// A strictly monotonic announcement counter, with gaps allowed
1132 /// The `node_id` this announcement originated from (don't rebroadcast the `node_announcement` back
1134 pub node_id: NodeId,
1135 /// An RGB color for UI purposes
1137 /// An alias, for UI purposes.
1139 /// This should be sanitized before use. There is no guarantee of uniqueness.
1140 pub alias: NodeAlias,
1141 /// List of addresses on which this node is reachable
1142 pub addresses: Vec<SocketAddress>,
1143 /// Excess address data which was signed as a part of the message which we do not (yet) understand how
1146 /// This is stored to ensure forward-compatibility as new address types are added to the lightning gossip protocol.
1147 pub excess_address_data: Vec<u8>,
1148 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1151 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1152 pub excess_data: Vec<u8>,
1154 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1155 /// A [`node_announcement`] message to be sent to or received from a peer.
1157 /// [`node_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-node_announcement-message
1158 pub struct NodeAnnouncement {
1159 /// The signature by the node key
1160 pub signature: Signature,
1161 /// The actual content of the announcement
1162 pub contents: UnsignedNodeAnnouncement,
1165 /// The unsigned part of a [`channel_announcement`] message.
1167 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1168 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1169 pub struct UnsignedChannelAnnouncement {
1170 /// The advertised channel features
1171 pub features: ChannelFeatures,
1172 /// The genesis hash of the blockchain where the channel is to be opened
1173 pub chain_hash: ChainHash,
1174 /// The short channel ID
1175 pub short_channel_id: u64,
1176 /// One of the two `node_id`s which are endpoints of this channel
1177 pub node_id_1: NodeId,
1178 /// The other of the two `node_id`s which are endpoints of this channel
1179 pub node_id_2: NodeId,
1180 /// The funding key for the first node
1181 pub bitcoin_key_1: NodeId,
1182 /// The funding key for the second node
1183 pub bitcoin_key_2: NodeId,
1184 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1187 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1188 pub excess_data: Vec<u8>,
1190 /// A [`channel_announcement`] message to be sent to or received from a peer.
1192 /// [`channel_announcement`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_announcement-message
1193 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1194 pub struct ChannelAnnouncement {
1195 /// Authentication of the announcement by the first public node
1196 pub node_signature_1: Signature,
1197 /// Authentication of the announcement by the second public node
1198 pub node_signature_2: Signature,
1199 /// Proof of funding UTXO ownership by the first public node
1200 pub bitcoin_signature_1: Signature,
1201 /// Proof of funding UTXO ownership by the second public node
1202 pub bitcoin_signature_2: Signature,
1203 /// The actual announcement
1204 pub contents: UnsignedChannelAnnouncement,
1207 /// The unsigned part of a [`channel_update`] message.
1209 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1210 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1211 pub struct UnsignedChannelUpdate {
1212 /// The genesis hash of the blockchain where the channel is to be opened
1213 pub chain_hash: ChainHash,
1214 /// The short channel ID
1215 pub short_channel_id: u64,
1216 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
1220 /// The number of blocks such that if:
1221 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
1222 /// then we need to fail the HTLC backwards. When forwarding an HTLC, `cltv_expiry_delta` determines
1223 /// the outgoing HTLC's minimum `cltv_expiry` value -- so, if an incoming HTLC comes in with a
1224 /// `cltv_expiry` of 100000, and the node we're forwarding to has a `cltv_expiry_delta` value of 10,
1225 /// then we'll check that the outgoing HTLC's `cltv_expiry` value is at least 100010 before
1226 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
1227 /// constructing the route.
1228 pub cltv_expiry_delta: u16,
1229 /// The minimum HTLC size incoming to sender, in milli-satoshi
1230 pub htlc_minimum_msat: u64,
1231 /// The maximum HTLC value incoming to sender, in milli-satoshi.
1233 /// This used to be optional.
1234 pub htlc_maximum_msat: u64,
1235 /// The base HTLC fee charged by sender, in milli-satoshi
1236 pub fee_base_msat: u32,
1237 /// The amount to fee multiplier, in micro-satoshi
1238 pub fee_proportional_millionths: u32,
1239 /// Excess data which was signed as a part of the message which we do not (yet) understand how
1242 /// This is stored to ensure forward-compatibility as new fields are added to the lightning gossip protocol.
1243 pub excess_data: Vec<u8>,
1245 /// A [`channel_update`] message to be sent to or received from a peer.
1247 /// [`channel_update`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message
1248 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1249 pub struct ChannelUpdate {
1250 /// A signature of the channel update
1251 pub signature: Signature,
1252 /// The actual channel update
1253 pub contents: UnsignedChannelUpdate,
1256 /// A [`query_channel_range`] message is used to query a peer for channel
1257 /// UTXOs in a range of blocks. The recipient of a query makes a best
1258 /// effort to reply to the query using one or more [`ReplyChannelRange`]
1261 /// [`query_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1262 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1263 pub struct QueryChannelRange {
1264 /// The genesis hash of the blockchain being queried
1265 pub chain_hash: ChainHash,
1266 /// The height of the first block for the channel UTXOs being queried
1267 pub first_blocknum: u32,
1268 /// The number of blocks to include in the query results
1269 pub number_of_blocks: u32,
1272 /// A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
1275 /// Multiple `reply_channel_range` messages can be sent in reply
1276 /// to a single [`QueryChannelRange`] message. The query recipient makes a
1277 /// best effort to respond based on their local network view which may
1278 /// not be a perfect view of the network. The `short_channel_id`s in the
1279 /// reply are encoded. We only support `encoding_type=0` uncompressed
1280 /// serialization and do not support `encoding_type=1` zlib serialization.
1282 /// [`reply_channel_range`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-query_channel_range-and-reply_channel_range-messages
1283 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1284 pub struct ReplyChannelRange {
1285 /// The genesis hash of the blockchain being queried
1286 pub chain_hash: ChainHash,
1287 /// The height of the first block in the range of the reply
1288 pub first_blocknum: u32,
1289 /// The number of blocks included in the range of the reply
1290 pub number_of_blocks: u32,
1291 /// True when this is the final reply for a query
1292 pub sync_complete: bool,
1293 /// The `short_channel_id`s in the channel range
1294 pub short_channel_ids: Vec<u64>,
1297 /// A [`query_short_channel_ids`] message is used to query a peer for
1298 /// routing gossip messages related to one or more `short_channel_id`s.
1300 /// The query recipient will reply with the latest, if available,
1301 /// [`ChannelAnnouncement`], [`ChannelUpdate`] and [`NodeAnnouncement`] messages
1302 /// it maintains for the requested `short_channel_id`s followed by a
1303 /// [`ReplyShortChannelIdsEnd`] message. The `short_channel_id`s sent in
1304 /// this query are encoded. We only support `encoding_type=0` uncompressed
1305 /// serialization and do not support `encoding_type=1` zlib serialization.
1307 /// [`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
1308 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1309 pub struct QueryShortChannelIds {
1310 /// The genesis hash of the blockchain being queried
1311 pub chain_hash: ChainHash,
1312 /// The short_channel_ids that are being queried
1313 pub short_channel_ids: Vec<u64>,
1316 /// A [`reply_short_channel_ids_end`] message is sent as a reply to a
1317 /// message. The query recipient makes a best
1318 /// effort to respond based on their local network view which may not be
1319 /// a perfect view of the network.
1321 /// [`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
1322 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1323 pub struct ReplyShortChannelIdsEnd {
1324 /// The genesis hash of the blockchain that was queried
1325 pub chain_hash: ChainHash,
1326 /// Indicates if the query recipient maintains up-to-date channel
1327 /// information for the `chain_hash`
1328 pub full_information: bool,
1331 /// A [`gossip_timestamp_filter`] message is used by a node to request
1332 /// gossip relay for messages in the requested time range when the
1333 /// `gossip_queries` feature has been negotiated.
1335 /// [`gossip_timestamp_filter`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-gossip_timestamp_filter-message
1336 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1337 pub struct GossipTimestampFilter {
1338 /// The genesis hash of the blockchain for channel and node information
1339 pub chain_hash: ChainHash,
1340 /// The starting unix timestamp
1341 pub first_timestamp: u32,
1342 /// The range of information in seconds
1343 pub timestamp_range: u32,
1346 /// Encoding type for data compression of collections in gossip queries.
1348 /// We do not support `encoding_type=1` zlib serialization [defined in BOLT
1349 /// #7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#query-messages).
1351 Uncompressed = 0x00,
1354 /// Used to put an error message in a [`LightningError`].
1355 #[derive(Clone, Debug, Hash, PartialEq)]
1356 pub enum ErrorAction {
1357 /// The peer took some action which made us think they were useless. Disconnect them.
1359 /// An error message which we should make an effort to send before we disconnect.
1360 msg: Option<ErrorMessage>
1362 /// The peer did something incorrect. Tell them without closing any channels and disconnect them.
1363 DisconnectPeerWithWarning {
1364 /// A warning message which we should make an effort to send before we disconnect.
1365 msg: WarningMessage,
1367 /// The peer did something harmless that we weren't able to process, just log and ignore
1368 // New code should *not* use this. New code must use IgnoreAndLog, below!
1370 /// The peer did something harmless that we weren't able to meaningfully process.
1371 /// If the error is logged, log it at the given level.
1372 IgnoreAndLog(logger::Level),
1373 /// The peer provided us with a gossip message which we'd already seen. In most cases this
1374 /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
1375 /// our own channel announcements.
1376 IgnoreDuplicateGossip,
1377 /// The peer did something incorrect. Tell them.
1379 /// The message to send.
1382 /// The peer did something incorrect. Tell them without closing any channels.
1383 SendWarningMessage {
1384 /// The message to send.
1385 msg: WarningMessage,
1386 /// The peer may have done something harmless that we weren't able to meaningfully process,
1387 /// though we should still tell them about it.
1388 /// If this event is logged, log it at the given level.
1389 log_level: logger::Level,
1393 /// An Err type for failure to process messages.
1394 #[derive(Clone, Debug)]
1395 pub struct LightningError {
1396 /// A human-readable message describing the error
1398 /// The action which should be taken against the offending peer.
1399 pub action: ErrorAction,
1402 /// Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
1403 /// transaction updates if they were pending.
1404 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1405 pub struct CommitmentUpdate {
1406 /// `update_add_htlc` messages which should be sent
1407 pub update_add_htlcs: Vec<UpdateAddHTLC>,
1408 /// `update_fulfill_htlc` messages which should be sent
1409 pub update_fulfill_htlcs: Vec<UpdateFulfillHTLC>,
1410 /// `update_fail_htlc` messages which should be sent
1411 pub update_fail_htlcs: Vec<UpdateFailHTLC>,
1412 /// `update_fail_malformed_htlc` messages which should be sent
1413 pub update_fail_malformed_htlcs: Vec<UpdateFailMalformedHTLC>,
1414 /// An `update_fee` message which should be sent
1415 pub update_fee: Option<UpdateFee>,
1416 /// A `commitment_signed` message which should be sent
1417 pub commitment_signed: CommitmentSigned,
1420 /// A trait to describe an object which can receive channel messages.
1422 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
1423 /// they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
1424 pub trait ChannelMessageHandler : MessageSendEventsProvider {
1426 /// Handle an incoming `open_channel` message from the given peer.
1427 fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
1428 /// Handle an incoming `open_channel2` message from the given peer.
1429 fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
1430 /// Handle an incoming `accept_channel` message from the given peer.
1431 fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
1432 /// Handle an incoming `accept_channel2` message from the given peer.
1433 fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
1434 /// Handle an incoming `funding_created` message from the given peer.
1435 fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
1436 /// Handle an incoming `funding_signed` message from the given peer.
1437 fn handle_funding_signed(&self, their_node_id: &PublicKey, msg: &FundingSigned);
1438 /// Handle an incoming `channel_ready` message from the given peer.
1439 fn handle_channel_ready(&self, their_node_id: &PublicKey, msg: &ChannelReady);
1442 /// Handle an incoming `shutdown` message from the given peer.
1443 fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown);
1444 /// Handle an incoming `closing_signed` message from the given peer.
1445 fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned);
1448 /// Handle an incoming `stfu` message from the given peer.
1449 fn handle_stfu(&self, their_node_id: &PublicKey, msg: &Stfu);
1452 /// Handle an incoming `splice` message from the given peer.
1453 fn handle_splice(&self, their_node_id: &PublicKey, msg: &Splice);
1454 /// Handle an incoming `splice_ack` message from the given peer.
1455 fn handle_splice_ack(&self, their_node_id: &PublicKey, msg: &SpliceAck);
1456 /// Handle an incoming `splice_locked` message from the given peer.
1457 fn handle_splice_locked(&self, their_node_id: &PublicKey, msg: &SpliceLocked);
1459 // Interactive channel construction
1460 /// Handle an incoming `tx_add_input message` from the given peer.
1461 fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
1462 /// Handle an incoming `tx_add_output` message from the given peer.
1463 fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
1464 /// Handle an incoming `tx_remove_input` message from the given peer.
1465 fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
1466 /// Handle an incoming `tx_remove_output` message from the given peer.
1467 fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
1468 /// Handle an incoming `tx_complete message` from the given peer.
1469 fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
1470 /// Handle an incoming `tx_signatures` message from the given peer.
1471 fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
1472 /// Handle an incoming `tx_init_rbf` message from the given peer.
1473 fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
1474 /// Handle an incoming `tx_ack_rbf` message from the given peer.
1475 fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
1476 /// Handle an incoming `tx_abort message` from the given peer.
1477 fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
1480 /// Handle an incoming `update_add_htlc` message from the given peer.
1481 fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC);
1482 /// Handle an incoming `update_fulfill_htlc` message from the given peer.
1483 fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC);
1484 /// Handle an incoming `update_fail_htlc` message from the given peer.
1485 fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC);
1486 /// Handle an incoming `update_fail_malformed_htlc` message from the given peer.
1487 fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC);
1488 /// Handle an incoming `commitment_signed` message from the given peer.
1489 fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned);
1490 /// Handle an incoming `revoke_and_ack` message from the given peer.
1491 fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK);
1493 /// Handle an incoming `update_fee` message from the given peer.
1494 fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee);
1496 // Channel-to-announce:
1497 /// Handle an incoming `announcement_signatures` message from the given peer.
1498 fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures);
1500 // Connection loss/reestablish:
1501 /// Indicates a connection to the peer failed/an existing connection was lost.
1502 fn peer_disconnected(&self, their_node_id: &PublicKey);
1504 /// Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
1506 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1507 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1508 /// message handlers may still wish to communicate with this peer.
1509 fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init, inbound: bool) -> Result<(), ()>;
1510 /// Handle an incoming `channel_reestablish` message from the given peer.
1511 fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
1513 /// Handle an incoming `channel_update` message from the given peer.
1514 fn handle_channel_update(&self, their_node_id: &PublicKey, msg: &ChannelUpdate);
1517 /// Handle an incoming `error` message from the given peer.
1518 fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
1520 // Handler information:
1521 /// Gets the node feature flags which this handler itself supports. All available handlers are
1522 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1523 /// which are broadcasted in our [`NodeAnnouncement`] message.
1524 fn provided_node_features(&self) -> NodeFeatures;
1526 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1527 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1528 /// which are sent in our [`Init`] message.
1530 /// Note that this method is called before [`Self::peer_connected`].
1531 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1533 /// Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
1535 /// If it's `None`, then no particular network chain hash compatibility will be enforced when
1536 /// connecting to peers.
1537 fn get_chain_hashes(&self) -> Option<Vec<ChainHash>>;
1540 /// A trait to describe an object which can receive routing messages.
1542 /// # Implementor DoS Warnings
1544 /// For messages enabled with the `gossip_queries` feature there are potential DoS vectors when
1545 /// handling inbound queries. Implementors using an on-disk network graph should be aware of
1546 /// repeated disk I/O for queries accessing different parts of the network graph.
1547 pub trait RoutingMessageHandler : MessageSendEventsProvider {
1548 /// Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
1549 /// `false` or returning an `Err` otherwise.
1550 fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError>;
1551 /// Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
1552 /// or returning an `Err` otherwise.
1553 fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError>;
1554 /// Handle an incoming `channel_update` message, returning true if it should be forwarded on,
1555 /// `false` or returning an `Err` otherwise.
1556 fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError>;
1557 /// Gets channel announcements and updates required to dump our routing table to a remote node,
1558 /// starting at the `short_channel_id` indicated by `starting_point` and including announcements
1559 /// for a single channel.
1560 fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)>;
1561 /// Gets a node announcement required to dump our routing table to a remote node, starting at
1562 /// the node *after* the provided pubkey and including up to one announcement immediately
1563 /// higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
1564 /// If `None` is provided for `starting_point`, we start at the first node.
1565 fn get_next_node_announcement(&self, starting_point: Option<&NodeId>) -> Option<NodeAnnouncement>;
1566 /// Called when a connection is established with a peer. This can be used to
1567 /// perform routing table synchronization using a strategy defined by the
1570 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1571 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1572 /// message handlers may still wish to communicate with this peer.
1573 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1574 /// Handles the reply of a query we initiated to learn about channels
1575 /// for a given range of blocks. We can expect to receive one or more
1576 /// replies to a single query.
1577 fn handle_reply_channel_range(&self, their_node_id: &PublicKey, msg: ReplyChannelRange) -> Result<(), LightningError>;
1578 /// Handles the reply of a query we initiated asking for routing gossip
1579 /// messages for a list of channels. We should receive this message when
1580 /// a node has completed its best effort to send us the pertaining routing
1581 /// gossip messages.
1582 fn handle_reply_short_channel_ids_end(&self, their_node_id: &PublicKey, msg: ReplyShortChannelIdsEnd) -> Result<(), LightningError>;
1583 /// Handles when a peer asks us to send a list of `short_channel_id`s
1584 /// for the requested range of blocks.
1585 fn handle_query_channel_range(&self, their_node_id: &PublicKey, msg: QueryChannelRange) -> Result<(), LightningError>;
1586 /// Handles when a peer asks us to send routing gossip messages for a
1587 /// list of `short_channel_id`s.
1588 fn handle_query_short_channel_ids(&self, their_node_id: &PublicKey, msg: QueryShortChannelIds) -> Result<(), LightningError>;
1590 // Handler queueing status:
1591 /// Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
1592 /// pending some async action. While there is no guarantee of the rate of future messages, the
1593 /// caller should seek to reduce the rate of new gossip messages handled, especially
1594 /// [`ChannelAnnouncement`]s.
1595 fn processing_queue_high(&self) -> bool;
1597 // Handler information:
1598 /// Gets the node feature flags which this handler itself supports. All available handlers are
1599 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1600 /// which are broadcasted in our [`NodeAnnouncement`] message.
1601 fn provided_node_features(&self) -> NodeFeatures;
1602 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1603 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1604 /// which are sent in our [`Init`] message.
1606 /// Note that this method is called before [`Self::peer_connected`].
1607 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1610 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
1611 pub trait OnionMessageHandler: EventsProvider {
1612 /// Handle an incoming `onion_message` message from the given peer.
1613 fn handle_onion_message(&self, peer_node_id: &PublicKey, msg: &OnionMessage);
1615 /// Returns the next pending onion message for the peer with the given node id.
1616 fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage>;
1618 /// Called when a connection is established with a peer. Can be used to track which peers
1619 /// advertise onion message support and are online.
1621 /// May return an `Err(())` if the features the peer supports are not sufficient to communicate
1622 /// with us. Implementors should be somewhat conservative about doing so, however, as other
1623 /// message handlers may still wish to communicate with this peer.
1624 fn peer_connected(&self, their_node_id: &PublicKey, init: &Init, inbound: bool) -> Result<(), ()>;
1626 /// Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
1627 /// drop and refuse to forward onion messages to this peer.
1628 fn peer_disconnected(&self, their_node_id: &PublicKey);
1630 /// Performs actions that should happen roughly every ten seconds after startup. Allows handlers
1631 /// to drop any buffered onion messages intended for prospective peers.
1632 fn timer_tick_occurred(&self);
1634 // Handler information:
1635 /// Gets the node feature flags which this handler itself supports. All available handlers are
1636 /// queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
1637 /// which are broadcasted in our [`NodeAnnouncement`] message.
1638 fn provided_node_features(&self) -> NodeFeatures;
1640 /// Gets the init feature flags which should be sent to the given peer. All available handlers
1641 /// are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
1642 /// which are sent in our [`Init`] message.
1644 /// Note that this method is called before [`Self::peer_connected`].
1645 fn provided_init_features(&self, their_node_id: &PublicKey) -> InitFeatures;
1649 #[cfg_attr(test, derive(Debug, PartialEq))]
1650 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
1651 /// the payment is associated with an invoice.
1652 pub struct FinalOnionHopData {
1653 /// When sending a multi-part payment, this secret is used to identify a payment across HTLCs.
1654 /// Because it is generated by the recipient and included in the invoice, it also provides
1655 /// proof to the recipient that the payment was sent by someone with the generated invoice.
1656 pub payment_secret: PaymentSecret,
1657 /// The intended total amount that this payment is for.
1659 /// Message serialization may panic if this value is more than 21 million Bitcoin.
1660 pub total_msat: u64,
1663 mod fuzzy_internal_msgs {
1664 use bitcoin::secp256k1::PublicKey;
1665 use crate::blinded_path::payment::{PaymentConstraints, PaymentRelay};
1666 use crate::prelude::*;
1667 use crate::ln::{PaymentPreimage, PaymentSecret};
1668 use crate::ln::features::BlindedHopFeatures;
1669 use super::{FinalOnionHopData, TrampolineOnionPacket};
1671 // These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
1672 // them from untrusted input):
1674 pub enum InboundOnionPayload {
1676 short_channel_id: u64,
1677 /// The value, in msat, of the payment after this hop's fee is deducted.
1678 amt_to_forward: u64,
1679 outgoing_cltv_value: u32,
1682 payment_data: Option<FinalOnionHopData>,
1683 payment_metadata: Option<Vec<u8>>,
1684 keysend_preimage: Option<PaymentPreimage>,
1685 custom_tlvs: Vec<(u64, Vec<u8>)>,
1686 sender_intended_htlc_amt_msat: u64,
1687 cltv_expiry_height: u32,
1690 short_channel_id: u64,
1691 payment_relay: PaymentRelay,
1692 payment_constraints: PaymentConstraints,
1693 features: BlindedHopFeatures,
1694 intro_node_blinding_point: Option<PublicKey>,
1697 sender_intended_htlc_amt_msat: u64,
1699 cltv_expiry_height: u32,
1700 payment_secret: PaymentSecret,
1701 payment_constraints: PaymentConstraints,
1702 intro_node_blinding_point: Option<PublicKey>,
1703 keysend_preimage: Option<PaymentPreimage>,
1707 pub(crate) enum OutboundOnionPayload {
1709 short_channel_id: u64,
1710 /// The value, in msat, of the payment after this hop's fee is deducted.
1711 amt_to_forward: u64,
1712 outgoing_cltv_value: u32,
1715 TrampolineEntrypoint {
1716 amt_to_forward: u64,
1717 outgoing_cltv_value: u32,
1718 multipath_trampoline_data: Option<FinalOnionHopData>,
1719 trampoline_packet: TrampolineOnionPacket,
1722 payment_data: Option<FinalOnionHopData>,
1723 payment_metadata: Option<Vec<u8>>,
1724 keysend_preimage: Option<PaymentPreimage>,
1725 custom_tlvs: Vec<(u64, Vec<u8>)>,
1726 sender_intended_htlc_amt_msat: u64,
1727 cltv_expiry_height: u32,
1730 encrypted_tlvs: Vec<u8>,
1731 intro_node_blinding_point: Option<PublicKey>,
1734 sender_intended_htlc_amt_msat: u64,
1736 cltv_expiry_height: u32,
1737 encrypted_tlvs: Vec<u8>,
1738 intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
1739 keysend_preimage: Option<PaymentPreimage>,
1740 custom_tlvs: Vec<(u64, Vec<u8>)>,
1744 pub struct DecodedOnionErrorPacket {
1745 pub(crate) hmac: [u8; 32],
1746 pub(crate) failuremsg: Vec<u8>,
1747 pub(crate) pad: Vec<u8>,
1751 pub use self::fuzzy_internal_msgs::*;
1752 #[cfg(not(fuzzing))]
1753 pub(crate) use self::fuzzy_internal_msgs::*;
1755 /// BOLT 4 onion packet including hop data for the next peer.
1756 #[derive(Clone, Hash, PartialEq, Eq)]
1757 pub struct OnionPacket {
1758 /// BOLT 4 version number.
1760 /// In order to ensure we always return an error on onion decode in compliance with [BOLT
1761 /// #4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md), we have to
1762 /// deserialize `OnionPacket`s contained in [`UpdateAddHTLC`] messages even if the ephemeral
1763 /// public key (here) is bogus, so we hold a [`Result`] instead of a [`PublicKey`] as we'd
1765 pub public_key: Result<PublicKey, secp256k1::Error>,
1766 /// 1300 bytes encrypted payload for the next hop.
1767 pub hop_data: [u8; 20*65],
1768 /// HMAC to verify the integrity of hop_data.
1772 impl onion_utils::Packet for OnionPacket {
1773 type Data = onion_utils::FixedSizeOnionPacket;
1774 fn new(pubkey: PublicKey, hop_data: onion_utils::FixedSizeOnionPacket, hmac: [u8; 32]) -> Self {
1777 public_key: Ok(pubkey),
1778 hop_data: hop_data.0,
1784 impl fmt::Debug for OnionPacket {
1785 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1786 f.write_fmt(format_args!("OnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1790 /// BOLT 4 onion packet including hop data for the next peer.
1791 #[derive(Clone, Hash, PartialEq, Eq)]
1792 pub struct TrampolineOnionPacket {
1793 /// Bolt 04 version number
1795 /// A random sepc256k1 point, used to build the ECDH shared secret to decrypt hop_data
1796 pub public_key: PublicKey,
1797 /// Encrypted payload for the next hop
1799 // Unlike the onion packets used for payments, Trampoline onion packets have to be shorter than
1800 // 1300 bytes. The expected default is 650 bytes.
1801 // TODO: if 650 ends up being the most common size, optimize this to be:
1802 // enum { ThirteenHundred([u8; 650]), VarLen(Vec<u8>) }
1803 pub hop_data: Vec<u8>,
1804 /// HMAC to verify the integrity of hop_data
1808 impl onion_utils::Packet for TrampolineOnionPacket {
1809 type Data = Vec<u8>;
1810 fn new(public_key: PublicKey, hop_data: Vec<u8>, hmac: [u8; 32]) -> Self {
1820 impl Writeable for TrampolineOnionPacket {
1821 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1822 self.version.write(w)?;
1823 self.public_key.write(w)?;
1824 w.write_all(&self.hop_data)?;
1825 self.hmac.write(w)?;
1830 impl Debug for TrampolineOnionPacket {
1831 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1832 f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
1836 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
1837 pub(crate) struct OnionErrorPacket {
1838 // This really should be a constant size slice, but the spec lets these things be up to 128KB?
1839 // (TODO) We limit it in decode to much lower...
1840 pub(crate) data: Vec<u8>,
1843 impl fmt::Display for DecodeError {
1844 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1846 DecodeError::UnknownVersion => f.write_str("Unknown realm byte in Onion packet"),
1847 DecodeError::UnknownRequiredFeature => f.write_str("Unknown required feature preventing decode"),
1848 DecodeError::InvalidValue => f.write_str("Nonsense bytes didn't map to the type they were interpreted as"),
1849 DecodeError::ShortRead => f.write_str("Packet extended beyond the provided bytes"),
1850 DecodeError::BadLengthDescriptor => f.write_str("A length descriptor in the packet didn't describe the later data correctly"),
1851 DecodeError::Io(ref e) => fmt::Debug::fmt(e, f),
1852 DecodeError::UnsupportedCompression => f.write_str("We don't support receiving messages with zlib-compressed fields"),
1857 impl From<io::Error> for DecodeError {
1858 fn from(e: io::Error) -> Self {
1859 if e.kind() == io::ErrorKind::UnexpectedEof {
1860 DecodeError::ShortRead
1862 DecodeError::Io(e.kind())
1867 impl Writeable for AcceptChannel {
1868 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1869 self.common_fields.temporary_channel_id.write(w)?;
1870 self.common_fields.dust_limit_satoshis.write(w)?;
1871 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1872 self.channel_reserve_satoshis.write(w)?;
1873 self.common_fields.htlc_minimum_msat.write(w)?;
1874 self.common_fields.minimum_depth.write(w)?;
1875 self.common_fields.to_self_delay.write(w)?;
1876 self.common_fields.max_accepted_htlcs.write(w)?;
1877 self.common_fields.funding_pubkey.write(w)?;
1878 self.common_fields.revocation_basepoint.write(w)?;
1879 self.common_fields.payment_basepoint.write(w)?;
1880 self.common_fields.delayed_payment_basepoint.write(w)?;
1881 self.common_fields.htlc_basepoint.write(w)?;
1882 self.common_fields.first_per_commitment_point.write(w)?;
1883 #[cfg(not(taproot))]
1884 encode_tlv_stream!(w, {
1885 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1886 (1, self.common_fields.channel_type, option),
1889 encode_tlv_stream!(w, {
1890 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1891 (1, self.common_fields.channel_type, option),
1892 (4, self.next_local_nonce, option),
1898 impl Readable for AcceptChannel {
1899 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1900 let temporary_channel_id: ChannelId = Readable::read(r)?;
1901 let dust_limit_satoshis: u64 = Readable::read(r)?;
1902 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1903 let channel_reserve_satoshis: u64 = Readable::read(r)?;
1904 let htlc_minimum_msat: u64 = Readable::read(r)?;
1905 let minimum_depth: u32 = Readable::read(r)?;
1906 let to_self_delay: u16 = Readable::read(r)?;
1907 let max_accepted_htlcs: u16 = Readable::read(r)?;
1908 let funding_pubkey: PublicKey = Readable::read(r)?;
1909 let revocation_basepoint: PublicKey = Readable::read(r)?;
1910 let payment_basepoint: PublicKey = Readable::read(r)?;
1911 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1912 let htlc_basepoint: PublicKey = Readable::read(r)?;
1913 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1915 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
1916 let mut channel_type: Option<ChannelTypeFeatures> = None;
1917 #[cfg(not(taproot))]
1918 decode_tlv_stream!(r, {
1919 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1920 (1, channel_type, option),
1923 let mut next_local_nonce: Option<musig2::types::PublicNonce> = None;
1925 decode_tlv_stream!(r, {
1926 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
1927 (1, channel_type, option),
1928 (4, next_local_nonce, option),
1932 common_fields: CommonAcceptChannelFields {
1933 temporary_channel_id,
1934 dust_limit_satoshis,
1935 max_htlc_value_in_flight_msat,
1941 revocation_basepoint,
1943 delayed_payment_basepoint,
1945 first_per_commitment_point,
1946 shutdown_scriptpubkey,
1949 channel_reserve_satoshis,
1956 impl Writeable for AcceptChannelV2 {
1957 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
1958 self.common_fields.temporary_channel_id.write(w)?;
1959 self.funding_satoshis.write(w)?;
1960 self.common_fields.dust_limit_satoshis.write(w)?;
1961 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
1962 self.common_fields.htlc_minimum_msat.write(w)?;
1963 self.common_fields.minimum_depth.write(w)?;
1964 self.common_fields.to_self_delay.write(w)?;
1965 self.common_fields.max_accepted_htlcs.write(w)?;
1966 self.common_fields.funding_pubkey.write(w)?;
1967 self.common_fields.revocation_basepoint.write(w)?;
1968 self.common_fields.payment_basepoint.write(w)?;
1969 self.common_fields.delayed_payment_basepoint.write(w)?;
1970 self.common_fields.htlc_basepoint.write(w)?;
1971 self.common_fields.first_per_commitment_point.write(w)?;
1972 self.second_per_commitment_point.write(w)?;
1974 encode_tlv_stream!(w, {
1975 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
1976 (1, self.common_fields.channel_type, option),
1977 (2, self.require_confirmed_inputs, option),
1983 impl Readable for AcceptChannelV2 {
1984 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
1985 let temporary_channel_id: ChannelId = Readable::read(r)?;
1986 let funding_satoshis: u64 = Readable::read(r)?;
1987 let dust_limit_satoshis: u64 = Readable::read(r)?;
1988 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
1989 let htlc_minimum_msat: u64 = Readable::read(r)?;
1990 let minimum_depth: u32 = Readable::read(r)?;
1991 let to_self_delay: u16 = Readable::read(r)?;
1992 let max_accepted_htlcs: u16 = Readable::read(r)?;
1993 let funding_pubkey: PublicKey = Readable::read(r)?;
1994 let revocation_basepoint: PublicKey = Readable::read(r)?;
1995 let payment_basepoint: PublicKey = Readable::read(r)?;
1996 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
1997 let htlc_basepoint: PublicKey = Readable::read(r)?;
1998 let first_per_commitment_point: PublicKey = Readable::read(r)?;
1999 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2001 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2002 let mut channel_type: Option<ChannelTypeFeatures> = None;
2003 let mut require_confirmed_inputs: Option<()> = None;
2004 decode_tlv_stream!(r, {
2005 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2006 (1, channel_type, option),
2007 (2, require_confirmed_inputs, option),
2010 Ok(AcceptChannelV2 {
2011 common_fields: CommonAcceptChannelFields {
2012 temporary_channel_id,
2013 dust_limit_satoshis,
2014 max_htlc_value_in_flight_msat,
2020 revocation_basepoint,
2022 delayed_payment_basepoint,
2024 first_per_commitment_point,
2025 shutdown_scriptpubkey,
2029 second_per_commitment_point,
2030 require_confirmed_inputs,
2035 impl_writeable_msg!(Stfu, {
2040 impl_writeable_msg!(Splice, {
2044 funding_feerate_perkw,
2049 impl_writeable_msg!(SpliceAck, {
2056 impl_writeable_msg!(SpliceLocked, {
2060 impl_writeable_msg!(TxAddInput, {
2068 impl_writeable_msg!(TxAddOutput, {
2075 impl_writeable_msg!(TxRemoveInput, {
2080 impl_writeable_msg!(TxRemoveOutput, {
2085 impl_writeable_msg!(TxComplete, {
2089 impl_writeable_msg!(TxSignatures, {
2095 impl_writeable_msg!(TxInitRbf, {
2098 feerate_sat_per_1000_weight,
2100 (0, funding_output_contribution, option),
2103 impl_writeable_msg!(TxAckRbf, {
2106 (0, funding_output_contribution, option),
2109 impl_writeable_msg!(TxAbort, {
2114 impl_writeable_msg!(AnnouncementSignatures, {
2121 impl_writeable_msg!(ChannelReestablish, {
2123 next_local_commitment_number,
2124 next_remote_commitment_number,
2125 your_last_per_commitment_secret,
2126 my_current_per_commitment_point,
2128 (0, next_funding_txid, option),
2131 impl_writeable_msg!(ClosingSigned,
2132 { channel_id, fee_satoshis, signature },
2133 { (1, fee_range, option) }
2136 impl_writeable!(ClosingSignedFeeRange, {
2141 #[cfg(not(taproot))]
2142 impl_writeable_msg!(CommitmentSigned, {
2149 impl_writeable_msg!(CommitmentSigned, {
2154 (2, partial_signature_with_nonce, option)
2157 impl_writeable!(DecodedOnionErrorPacket, {
2163 #[cfg(not(taproot))]
2164 impl_writeable_msg!(FundingCreated, {
2165 temporary_channel_id,
2167 funding_output_index,
2171 impl_writeable_msg!(FundingCreated, {
2172 temporary_channel_id,
2174 funding_output_index,
2177 (2, partial_signature_with_nonce, option),
2178 (4, next_local_nonce, option)
2181 #[cfg(not(taproot))]
2182 impl_writeable_msg!(FundingSigned, {
2188 impl_writeable_msg!(FundingSigned, {
2192 (2, partial_signature_with_nonce, option)
2195 impl_writeable_msg!(ChannelReady, {
2197 next_per_commitment_point,
2199 (1, short_channel_id_alias, option),
2202 impl Writeable for Init {
2203 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2204 // global_features gets the bottom 13 bits of our features, and local_features gets all of
2205 // our relevant feature bits. This keeps us compatible with old nodes.
2206 self.features.write_up_to_13(w)?;
2207 self.features.write(w)?;
2208 encode_tlv_stream!(w, {
2209 (1, self.networks.as_ref().map(|n| WithoutLength(n)), option),
2210 (3, self.remote_network_address, option),
2216 impl Readable for Init {
2217 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2218 let global_features: InitFeatures = Readable::read(r)?;
2219 let features: InitFeatures = Readable::read(r)?;
2220 let mut remote_network_address: Option<SocketAddress> = None;
2221 let mut networks: Option<WithoutLength<Vec<ChainHash>>> = None;
2222 decode_tlv_stream!(r, {
2223 (1, networks, option),
2224 (3, remote_network_address, option)
2227 features: features | global_features,
2228 networks: networks.map(|n| n.0),
2229 remote_network_address,
2234 impl Writeable for OpenChannel {
2235 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2236 self.common_fields.chain_hash.write(w)?;
2237 self.common_fields.temporary_channel_id.write(w)?;
2238 self.common_fields.funding_satoshis.write(w)?;
2239 self.push_msat.write(w)?;
2240 self.common_fields.dust_limit_satoshis.write(w)?;
2241 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2242 self.channel_reserve_satoshis.write(w)?;
2243 self.common_fields.htlc_minimum_msat.write(w)?;
2244 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2245 self.common_fields.to_self_delay.write(w)?;
2246 self.common_fields.max_accepted_htlcs.write(w)?;
2247 self.common_fields.funding_pubkey.write(w)?;
2248 self.common_fields.revocation_basepoint.write(w)?;
2249 self.common_fields.payment_basepoint.write(w)?;
2250 self.common_fields.delayed_payment_basepoint.write(w)?;
2251 self.common_fields.htlc_basepoint.write(w)?;
2252 self.common_fields.first_per_commitment_point.write(w)?;
2253 self.common_fields.channel_flags.write(w)?;
2254 encode_tlv_stream!(w, {
2255 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2256 (1, self.common_fields.channel_type, option),
2262 impl Readable for OpenChannel {
2263 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2264 let chain_hash: ChainHash = Readable::read(r)?;
2265 let temporary_channel_id: ChannelId = Readable::read(r)?;
2266 let funding_satoshis: u64 = Readable::read(r)?;
2267 let push_msat: u64 = Readable::read(r)?;
2268 let dust_limit_satoshis: u64 = Readable::read(r)?;
2269 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2270 let channel_reserve_satoshis: u64 = Readable::read(r)?;
2271 let htlc_minimum_msat: u64 = Readable::read(r)?;
2272 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2273 let to_self_delay: u16 = Readable::read(r)?;
2274 let max_accepted_htlcs: u16 = Readable::read(r)?;
2275 let funding_pubkey: PublicKey = Readable::read(r)?;
2276 let revocation_basepoint: PublicKey = Readable::read(r)?;
2277 let payment_basepoint: PublicKey = Readable::read(r)?;
2278 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2279 let htlc_basepoint: PublicKey = Readable::read(r)?;
2280 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2281 let channel_flags: u8 = Readable::read(r)?;
2283 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2284 let mut channel_type: Option<ChannelTypeFeatures> = None;
2285 decode_tlv_stream!(r, {
2286 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2287 (1, channel_type, option),
2290 common_fields: CommonOpenChannelFields {
2292 temporary_channel_id,
2294 dust_limit_satoshis,
2295 max_htlc_value_in_flight_msat,
2297 commitment_feerate_sat_per_1000_weight,
2301 revocation_basepoint,
2303 delayed_payment_basepoint,
2305 first_per_commitment_point,
2307 shutdown_scriptpubkey,
2311 channel_reserve_satoshis,
2316 impl Writeable for OpenChannelV2 {
2317 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2318 self.common_fields.chain_hash.write(w)?;
2319 self.common_fields.temporary_channel_id.write(w)?;
2320 self.funding_feerate_sat_per_1000_weight.write(w)?;
2321 self.common_fields.commitment_feerate_sat_per_1000_weight.write(w)?;
2322 self.common_fields.funding_satoshis.write(w)?;
2323 self.common_fields.dust_limit_satoshis.write(w)?;
2324 self.common_fields.max_htlc_value_in_flight_msat.write(w)?;
2325 self.common_fields.htlc_minimum_msat.write(w)?;
2326 self.common_fields.to_self_delay.write(w)?;
2327 self.common_fields.max_accepted_htlcs.write(w)?;
2328 self.locktime.write(w)?;
2329 self.common_fields.funding_pubkey.write(w)?;
2330 self.common_fields.revocation_basepoint.write(w)?;
2331 self.common_fields.payment_basepoint.write(w)?;
2332 self.common_fields.delayed_payment_basepoint.write(w)?;
2333 self.common_fields.htlc_basepoint.write(w)?;
2334 self.common_fields.first_per_commitment_point.write(w)?;
2335 self.second_per_commitment_point.write(w)?;
2336 self.common_fields.channel_flags.write(w)?;
2337 encode_tlv_stream!(w, {
2338 (0, self.common_fields.shutdown_scriptpubkey.as_ref().map(|s| WithoutLength(s)), option), // Don't encode length twice.
2339 (1, self.common_fields.channel_type, option),
2340 (2, self.require_confirmed_inputs, option),
2346 impl Readable for OpenChannelV2 {
2347 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2348 let chain_hash: ChainHash = Readable::read(r)?;
2349 let temporary_channel_id: ChannelId = Readable::read(r)?;
2350 let funding_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2351 let commitment_feerate_sat_per_1000_weight: u32 = Readable::read(r)?;
2352 let funding_satoshis: u64 = Readable::read(r)?;
2353 let dust_limit_satoshis: u64 = Readable::read(r)?;
2354 let max_htlc_value_in_flight_msat: u64 = Readable::read(r)?;
2355 let htlc_minimum_msat: u64 = Readable::read(r)?;
2356 let to_self_delay: u16 = Readable::read(r)?;
2357 let max_accepted_htlcs: u16 = Readable::read(r)?;
2358 let locktime: u32 = Readable::read(r)?;
2359 let funding_pubkey: PublicKey = Readable::read(r)?;
2360 let revocation_basepoint: PublicKey = Readable::read(r)?;
2361 let payment_basepoint: PublicKey = Readable::read(r)?;
2362 let delayed_payment_basepoint: PublicKey = Readable::read(r)?;
2363 let htlc_basepoint: PublicKey = Readable::read(r)?;
2364 let first_per_commitment_point: PublicKey = Readable::read(r)?;
2365 let second_per_commitment_point: PublicKey = Readable::read(r)?;
2366 let channel_flags: u8 = Readable::read(r)?;
2368 let mut shutdown_scriptpubkey: Option<ScriptBuf> = None;
2369 let mut channel_type: Option<ChannelTypeFeatures> = None;
2370 let mut require_confirmed_inputs: Option<()> = None;
2371 decode_tlv_stream!(r, {
2372 (0, shutdown_scriptpubkey, (option, encoding: (ScriptBuf, WithoutLength))),
2373 (1, channel_type, option),
2374 (2, require_confirmed_inputs, option),
2377 common_fields: CommonOpenChannelFields {
2379 temporary_channel_id,
2381 dust_limit_satoshis,
2382 max_htlc_value_in_flight_msat,
2384 commitment_feerate_sat_per_1000_weight,
2388 revocation_basepoint,
2390 delayed_payment_basepoint,
2392 first_per_commitment_point,
2394 shutdown_scriptpubkey,
2397 funding_feerate_sat_per_1000_weight,
2399 second_per_commitment_point,
2400 require_confirmed_inputs,
2405 #[cfg(not(taproot))]
2406 impl_writeable_msg!(RevokeAndACK, {
2408 per_commitment_secret,
2409 next_per_commitment_point
2413 impl_writeable_msg!(RevokeAndACK, {
2415 per_commitment_secret,
2416 next_per_commitment_point
2418 (4, next_local_nonce, option)
2421 impl_writeable_msg!(Shutdown, {
2426 impl_writeable_msg!(UpdateFailHTLC, {
2432 impl_writeable_msg!(UpdateFailMalformedHTLC, {
2439 impl_writeable_msg!(UpdateFee, {
2444 impl_writeable_msg!(UpdateFulfillHTLC, {
2450 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2451 // serialization format in a way which assumes we know the total serialized length/message end
2453 impl_writeable!(OnionErrorPacket, {
2457 // Note that this is written as a part of ChannelManager objects, and thus cannot change its
2458 // serialization format in a way which assumes we know the total serialized length/message end
2460 impl Writeable for OnionPacket {
2461 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2462 self.version.write(w)?;
2463 match self.public_key {
2464 Ok(pubkey) => pubkey.write(w)?,
2465 Err(_) => [0u8;33].write(w)?,
2467 w.write_all(&self.hop_data)?;
2468 self.hmac.write(w)?;
2473 impl Readable for OnionPacket {
2474 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2476 version: Readable::read(r)?,
2478 let mut buf = [0u8;33];
2479 r.read_exact(&mut buf)?;
2480 PublicKey::from_slice(&buf)
2482 hop_data: Readable::read(r)?,
2483 hmac: Readable::read(r)?,
2488 impl_writeable_msg!(UpdateAddHTLC, {
2494 onion_routing_packet,
2496 (0, blinding_point, option),
2497 (65537, skimmed_fee_msat, option)
2500 impl Readable for OnionMessage {
2501 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2502 let blinding_point: PublicKey = Readable::read(r)?;
2503 let len: u16 = Readable::read(r)?;
2504 let mut packet_reader = FixedLengthReader::new(r, len as u64);
2505 let onion_routing_packet: onion_message::packet::Packet =
2506 <onion_message::packet::Packet as LengthReadable>::read(&mut packet_reader)?;
2509 onion_routing_packet,
2514 impl Writeable for OnionMessage {
2515 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2516 self.blinding_point.write(w)?;
2517 let onion_packet_len = self.onion_routing_packet.serialized_length();
2518 (onion_packet_len as u16).write(w)?;
2519 self.onion_routing_packet.write(w)?;
2524 impl Writeable for FinalOnionHopData {
2525 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2526 self.payment_secret.0.write(w)?;
2527 HighZeroBytesDroppedBigSize(self.total_msat).write(w)
2531 impl Readable for FinalOnionHopData {
2532 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2533 let secret: [u8; 32] = Readable::read(r)?;
2534 let amt: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
2535 Ok(Self { payment_secret: PaymentSecret(secret), total_msat: amt.0 })
2539 impl Writeable for OutboundOnionPayload {
2540 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2542 Self::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } => {
2543 _encode_varint_length_prefixed_tlv!(w, {
2544 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2545 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2546 (6, short_channel_id, required)
2549 Self::TrampolineEntrypoint {
2550 amt_to_forward, outgoing_cltv_value, ref multipath_trampoline_data,
2551 ref trampoline_packet
2553 _encode_varint_length_prefixed_tlv!(w, {
2554 (2, HighZeroBytesDroppedBigSize(*amt_to_forward), required),
2555 (4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
2556 (8, multipath_trampoline_data, option),
2557 (20, trampoline_packet, required)
2561 ref payment_data, ref payment_metadata, ref keysend_preimage, sender_intended_htlc_amt_msat,
2562 cltv_expiry_height, ref custom_tlvs,
2564 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2565 // to reject any reserved types in the experimental range if new ones are ever
2567 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2568 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2569 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2570 _encode_varint_length_prefixed_tlv!(w, {
2571 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2572 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2573 (8, payment_data, option),
2574 (16, payment_metadata.as_ref().map(|m| WithoutLength(m)), option)
2575 }, custom_tlvs.iter());
2577 Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
2578 _encode_varint_length_prefixed_tlv!(w, {
2579 (10, *encrypted_tlvs, required_vec),
2580 (12, intro_node_blinding_point, option)
2583 Self::BlindedReceive {
2584 sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
2585 intro_node_blinding_point, keysend_preimage, ref custom_tlvs,
2587 // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
2588 // to reject any reserved types in the experimental range if new ones are ever
2590 let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
2591 let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
2592 custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
2593 _encode_varint_length_prefixed_tlv!(w, {
2594 (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
2595 (4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
2596 (10, *encrypted_tlvs, required_vec),
2597 (12, intro_node_blinding_point, option),
2598 (18, HighZeroBytesDroppedBigSize(*total_msat), required)
2599 }, custom_tlvs.iter());
2606 impl<NS: Deref> ReadableArgs<(Option<PublicKey>, &NS)> for InboundOnionPayload where NS::Target: NodeSigner {
2607 fn read<R: Read>(r: &mut R, args: (Option<PublicKey>, &NS)) -> Result<Self, DecodeError> {
2608 let (update_add_blinding_point, node_signer) = args;
2611 let mut cltv_value = None;
2612 let mut short_id: Option<u64> = None;
2613 let mut payment_data: Option<FinalOnionHopData> = None;
2614 let mut encrypted_tlvs_opt: Option<WithoutLength<Vec<u8>>> = None;
2615 let mut intro_node_blinding_point = None;
2616 let mut payment_metadata: Option<WithoutLength<Vec<u8>>> = None;
2617 let mut total_msat = None;
2618 let mut keysend_preimage: Option<PaymentPreimage> = None;
2619 let mut custom_tlvs = Vec::new();
2621 let tlv_len = BigSize::read(r)?;
2622 let rd = FixedLengthReader::new(r, tlv_len.0);
2623 decode_tlv_stream_with_custom_tlv_decode!(rd, {
2624 (2, amt, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2625 (4, cltv_value, (option, encoding: (u32, HighZeroBytesDroppedBigSize))),
2626 (6, short_id, option),
2627 (8, payment_data, option),
2628 (10, encrypted_tlvs_opt, option),
2629 (12, intro_node_blinding_point, option),
2630 (16, payment_metadata, option),
2631 (18, total_msat, (option, encoding: (u64, HighZeroBytesDroppedBigSize))),
2632 // See https://github.com/lightning/blips/blob/master/blip-0003.md
2633 (5482373484, keysend_preimage, option)
2634 }, |msg_type: u64, msg_reader: &mut FixedLengthReader<_>| -> Result<bool, DecodeError> {
2635 if msg_type < 1 << 16 { return Ok(false) }
2636 let mut value = Vec::new();
2637 msg_reader.read_to_end(&mut value)?;
2638 custom_tlvs.push((msg_type, value));
2642 if amt.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2643 if intro_node_blinding_point.is_some() && update_add_blinding_point.is_some() {
2644 return Err(DecodeError::InvalidValue)
2647 if let Some(blinding_point) = intro_node_blinding_point.or(update_add_blinding_point) {
2648 if short_id.is_some() || payment_data.is_some() || payment_metadata.is_some() {
2649 return Err(DecodeError::InvalidValue)
2651 let enc_tlvs = encrypted_tlvs_opt.ok_or(DecodeError::InvalidValue)?.0;
2652 let enc_tlvs_ss = node_signer.ecdh(Recipient::Node, &blinding_point, None)
2653 .map_err(|_| DecodeError::InvalidValue)?;
2654 let rho = onion_utils::gen_rho_from_shared_secret(&enc_tlvs_ss.secret_bytes());
2655 let mut s = Cursor::new(&enc_tlvs);
2656 let mut reader = FixedLengthReader::new(&mut s, enc_tlvs.len() as u64);
2657 match ChaChaPolyReadAdapter::read(&mut reader, rho)? {
2658 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Forward(ForwardTlvs {
2659 short_channel_id, payment_relay, payment_constraints, features
2661 if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
2662 keysend_preimage.is_some()
2664 return Err(DecodeError::InvalidValue)
2666 Ok(Self::BlindedForward {
2669 payment_constraints,
2671 intro_node_blinding_point,
2674 ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(ReceiveTlvs {
2675 payment_secret, payment_constraints
2677 if total_msat.unwrap_or(0) > MAX_VALUE_MSAT { return Err(DecodeError::InvalidValue) }
2678 Ok(Self::BlindedReceive {
2679 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2680 total_msat: total_msat.ok_or(DecodeError::InvalidValue)?,
2681 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2683 payment_constraints,
2684 intro_node_blinding_point,
2689 } else if let Some(short_channel_id) = short_id {
2690 if payment_data.is_some() || payment_metadata.is_some() || encrypted_tlvs_opt.is_some() ||
2691 total_msat.is_some()
2692 { return Err(DecodeError::InvalidValue) }
2695 amt_to_forward: amt.ok_or(DecodeError::InvalidValue)?,
2696 outgoing_cltv_value: cltv_value.ok_or(DecodeError::InvalidValue)?,
2699 if encrypted_tlvs_opt.is_some() || total_msat.is_some() {
2700 return Err(DecodeError::InvalidValue)
2702 if let Some(data) = &payment_data {
2703 if data.total_msat > MAX_VALUE_MSAT {
2704 return Err(DecodeError::InvalidValue);
2709 payment_metadata: payment_metadata.map(|w| w.0),
2711 sender_intended_htlc_amt_msat: amt.ok_or(DecodeError::InvalidValue)?,
2712 cltv_expiry_height: cltv_value.ok_or(DecodeError::InvalidValue)?,
2719 impl Writeable for Ping {
2720 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2721 self.ponglen.write(w)?;
2722 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2727 impl Readable for Ping {
2728 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2730 ponglen: Readable::read(r)?,
2732 let byteslen = Readable::read(r)?;
2733 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2740 impl Writeable for Pong {
2741 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2742 vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
2747 impl Readable for Pong {
2748 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2751 let byteslen = Readable::read(r)?;
2752 r.read_exact(&mut vec![0u8; byteslen as usize][..])?;
2759 impl Writeable for UnsignedChannelAnnouncement {
2760 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2761 self.features.write(w)?;
2762 self.chain_hash.write(w)?;
2763 self.short_channel_id.write(w)?;
2764 self.node_id_1.write(w)?;
2765 self.node_id_2.write(w)?;
2766 self.bitcoin_key_1.write(w)?;
2767 self.bitcoin_key_2.write(w)?;
2768 w.write_all(&self.excess_data[..])?;
2773 impl Readable for UnsignedChannelAnnouncement {
2774 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2776 features: Readable::read(r)?,
2777 chain_hash: Readable::read(r)?,
2778 short_channel_id: Readable::read(r)?,
2779 node_id_1: Readable::read(r)?,
2780 node_id_2: Readable::read(r)?,
2781 bitcoin_key_1: Readable::read(r)?,
2782 bitcoin_key_2: Readable::read(r)?,
2783 excess_data: read_to_end(r)?,
2788 impl_writeable!(ChannelAnnouncement, {
2791 bitcoin_signature_1,
2792 bitcoin_signature_2,
2796 impl Writeable for UnsignedChannelUpdate {
2797 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2798 // `message_flags` used to indicate presence of `htlc_maximum_msat`, but was deprecated in the spec.
2799 const MESSAGE_FLAGS: u8 = 1;
2800 self.chain_hash.write(w)?;
2801 self.short_channel_id.write(w)?;
2802 self.timestamp.write(w)?;
2803 let all_flags = self.flags as u16 | ((MESSAGE_FLAGS as u16) << 8);
2804 all_flags.write(w)?;
2805 self.cltv_expiry_delta.write(w)?;
2806 self.htlc_minimum_msat.write(w)?;
2807 self.fee_base_msat.write(w)?;
2808 self.fee_proportional_millionths.write(w)?;
2809 self.htlc_maximum_msat.write(w)?;
2810 w.write_all(&self.excess_data[..])?;
2815 impl Readable for UnsignedChannelUpdate {
2816 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2818 chain_hash: Readable::read(r)?,
2819 short_channel_id: Readable::read(r)?,
2820 timestamp: Readable::read(r)?,
2822 let flags: u16 = Readable::read(r)?;
2823 // Note: we ignore the `message_flags` for now, since it was deprecated by the spec.
2826 cltv_expiry_delta: Readable::read(r)?,
2827 htlc_minimum_msat: Readable::read(r)?,
2828 fee_base_msat: Readable::read(r)?,
2829 fee_proportional_millionths: Readable::read(r)?,
2830 htlc_maximum_msat: Readable::read(r)?,
2831 excess_data: read_to_end(r)?,
2836 impl_writeable!(ChannelUpdate, {
2841 impl Writeable for ErrorMessage {
2842 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2843 self.channel_id.write(w)?;
2844 (self.data.len() as u16).write(w)?;
2845 w.write_all(self.data.as_bytes())?;
2850 impl Readable for ErrorMessage {
2851 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2853 channel_id: Readable::read(r)?,
2855 let sz: usize = <u16 as Readable>::read(r)? as usize;
2856 let mut data = Vec::with_capacity(sz);
2858 r.read_exact(&mut data)?;
2859 match String::from_utf8(data) {
2861 Err(_) => return Err(DecodeError::InvalidValue),
2868 impl Writeable for WarningMessage {
2869 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2870 self.channel_id.write(w)?;
2871 (self.data.len() as u16).write(w)?;
2872 w.write_all(self.data.as_bytes())?;
2877 impl Readable for WarningMessage {
2878 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2880 channel_id: Readable::read(r)?,
2882 let sz: usize = <u16 as Readable>::read(r)? as usize;
2883 let mut data = Vec::with_capacity(sz);
2885 r.read_exact(&mut data)?;
2886 match String::from_utf8(data) {
2888 Err(_) => return Err(DecodeError::InvalidValue),
2895 impl Writeable for UnsignedNodeAnnouncement {
2896 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
2897 self.features.write(w)?;
2898 self.timestamp.write(w)?;
2899 self.node_id.write(w)?;
2900 w.write_all(&self.rgb)?;
2901 self.alias.write(w)?;
2903 let mut addr_len = 0;
2904 for addr in self.addresses.iter() {
2905 addr_len += 1 + addr.len();
2907 (addr_len + self.excess_address_data.len() as u16).write(w)?;
2908 for addr in self.addresses.iter() {
2911 w.write_all(&self.excess_address_data[..])?;
2912 w.write_all(&self.excess_data[..])?;
2917 impl Readable for UnsignedNodeAnnouncement {
2918 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2919 let features: NodeFeatures = Readable::read(r)?;
2920 let timestamp: u32 = Readable::read(r)?;
2921 let node_id: NodeId = Readable::read(r)?;
2922 let mut rgb = [0; 3];
2923 r.read_exact(&mut rgb)?;
2924 let alias: NodeAlias = Readable::read(r)?;
2926 let addr_len: u16 = Readable::read(r)?;
2927 let mut addresses: Vec<SocketAddress> = Vec::new();
2928 let mut addr_readpos = 0;
2929 let mut excess = false;
2930 let mut excess_byte = 0;
2932 if addr_len <= addr_readpos { break; }
2933 match Readable::read(r) {
2935 if addr_len < addr_readpos + 1 + addr.len() {
2936 return Err(DecodeError::BadLengthDescriptor);
2938 addr_readpos += (1 + addr.len()) as u16;
2939 addresses.push(addr);
2941 Ok(Err(unknown_descriptor)) => {
2943 excess_byte = unknown_descriptor;
2946 Err(DecodeError::ShortRead) => return Err(DecodeError::BadLengthDescriptor),
2947 Err(e) => return Err(e),
2951 let mut excess_data = vec![];
2952 let excess_address_data = if addr_readpos < addr_len {
2953 let mut excess_address_data = vec![0; (addr_len - addr_readpos) as usize];
2954 r.read_exact(&mut excess_address_data[if excess { 1 } else { 0 }..])?;
2956 excess_address_data[0] = excess_byte;
2961 excess_data.push(excess_byte);
2965 excess_data.extend(read_to_end(r)?.iter());
2966 Ok(UnsignedNodeAnnouncement {
2973 excess_address_data,
2979 impl_writeable!(NodeAnnouncement, {
2984 impl Readable for QueryShortChannelIds {
2985 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
2986 let chain_hash: ChainHash = Readable::read(r)?;
2988 let encoding_len: u16 = Readable::read(r)?;
2989 let encoding_type: u8 = Readable::read(r)?;
2991 // Must be encoding_type=0 uncompressed serialization. We do not
2992 // support encoding_type=1 zlib serialization.
2993 if encoding_type != EncodingType::Uncompressed as u8 {
2994 return Err(DecodeError::UnsupportedCompression);
2997 // We expect the encoding_len to always includes the 1-byte
2998 // encoding_type and that short_channel_ids are 8-bytes each
2999 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3000 return Err(DecodeError::InvalidValue);
3003 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3004 // less the 1-byte encoding_type
3005 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3006 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3007 for _ in 0..short_channel_id_count {
3008 short_channel_ids.push(Readable::read(r)?);
3011 Ok(QueryShortChannelIds {
3018 impl Writeable for QueryShortChannelIds {
3019 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3020 // Calculated from 1-byte encoding_type plus 8-bytes per short_channel_id
3021 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3023 self.chain_hash.write(w)?;
3024 encoding_len.write(w)?;
3026 // We only support type=0 uncompressed serialization
3027 (EncodingType::Uncompressed as u8).write(w)?;
3029 for scid in self.short_channel_ids.iter() {
3037 impl_writeable_msg!(ReplyShortChannelIdsEnd, {
3042 impl QueryChannelRange {
3043 /// Calculates the overflow safe ending block height for the query.
3045 /// Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`.
3046 pub fn end_blocknum(&self) -> u32 {
3047 match self.first_blocknum.checked_add(self.number_of_blocks) {
3048 Some(block) => block,
3049 None => u32::max_value(),
3054 impl_writeable_msg!(QueryChannelRange, {
3060 impl Readable for ReplyChannelRange {
3061 fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
3062 let chain_hash: ChainHash = Readable::read(r)?;
3063 let first_blocknum: u32 = Readable::read(r)?;
3064 let number_of_blocks: u32 = Readable::read(r)?;
3065 let sync_complete: bool = Readable::read(r)?;
3067 let encoding_len: u16 = Readable::read(r)?;
3068 let encoding_type: u8 = Readable::read(r)?;
3070 // Must be encoding_type=0 uncompressed serialization. We do not
3071 // support encoding_type=1 zlib serialization.
3072 if encoding_type != EncodingType::Uncompressed as u8 {
3073 return Err(DecodeError::UnsupportedCompression);
3076 // We expect the encoding_len to always includes the 1-byte
3077 // encoding_type and that short_channel_ids are 8-bytes each
3078 if encoding_len == 0 || (encoding_len - 1) % 8 != 0 {
3079 return Err(DecodeError::InvalidValue);
3082 // Read short_channel_ids (8-bytes each), for the u16 encoding_len
3083 // less the 1-byte encoding_type
3084 let short_channel_id_count: u16 = (encoding_len - 1)/8;
3085 let mut short_channel_ids = Vec::with_capacity(short_channel_id_count as usize);
3086 for _ in 0..short_channel_id_count {
3087 short_channel_ids.push(Readable::read(r)?);
3090 Ok(ReplyChannelRange {
3100 impl Writeable for ReplyChannelRange {
3101 fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
3102 let encoding_len: u16 = 1 + self.short_channel_ids.len() as u16 * 8;
3103 self.chain_hash.write(w)?;
3104 self.first_blocknum.write(w)?;
3105 self.number_of_blocks.write(w)?;
3106 self.sync_complete.write(w)?;
3108 encoding_len.write(w)?;
3109 (EncodingType::Uncompressed as u8).write(w)?;
3110 for scid in self.short_channel_ids.iter() {
3118 impl_writeable_msg!(GossipTimestampFilter, {
3126 use std::convert::TryFrom;
3127 use bitcoin::{Transaction, TxIn, ScriptBuf, Sequence, Witness, TxOut};
3128 use hex::DisplayHex;
3129 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
3130 use crate::ln::ChannelId;
3131 use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
3132 use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
3133 use crate::ln::msgs::SocketAddress;
3134 use crate::routing::gossip::{NodeAlias, NodeId};
3135 use crate::util::ser::{BigSize, Hostname, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
3136 use crate::util::test_utils;
3138 use bitcoin::hashes::hex::FromHex;
3139 use bitcoin::address::Address;
3140 use bitcoin::network::constants::Network;
3141 use bitcoin::blockdata::constants::ChainHash;
3142 use bitcoin::blockdata::script::Builder;
3143 use bitcoin::blockdata::opcodes;
3144 use bitcoin::hash_types::Txid;
3145 use bitcoin::locktime::absolute::LockTime;
3147 use bitcoin::secp256k1::{PublicKey,SecretKey};
3148 use bitcoin::secp256k1::{Secp256k1, Message};
3150 use crate::io::{self, Cursor};
3151 use crate::prelude::*;
3152 use core::str::FromStr;
3153 use crate::chain::transaction::OutPoint;
3155 #[cfg(feature = "std")]
3156 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
3157 #[cfg(feature = "std")]
3158 use crate::ln::msgs::SocketAddressParseError;
3161 fn encoding_channel_reestablish() {
3163 let secp_ctx = Secp256k1::new();
3164 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3167 let cr = msgs::ChannelReestablish {
3168 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]),
3169 next_local_commitment_number: 3,
3170 next_remote_commitment_number: 4,
3171 your_last_per_commitment_secret: [9;32],
3172 my_current_per_commitment_point: public_key,
3173 next_funding_txid: None,
3176 let encoded_value = cr.encode();
3180 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
3181 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3182 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3183 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
3184 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
3190 fn encoding_channel_reestablish_with_next_funding_txid() {
3192 let secp_ctx = Secp256k1::new();
3193 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap())
3196 let cr = msgs::ChannelReestablish {
3197 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]),
3198 next_local_commitment_number: 3,
3199 next_remote_commitment_number: 4,
3200 your_last_per_commitment_secret: [9;32],
3201 my_current_per_commitment_point: public_key,
3202 next_funding_txid: Some(Txid::from_raw_hash(bitcoin::hashes::Hash::from_slice(&[
3203 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,
3207 let encoded_value = cr.encode();
3211 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
3212 0, 0, 0, 0, 0, 0, 0, 3, // next_local_commitment_number
3213 0, 0, 0, 0, 0, 0, 0, 4, // next_remote_commitment_number
3214 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
3215 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
3216 0, // Type (next_funding_txid)
3218 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
3223 macro_rules! get_keys_from {
3224 ($slice: expr, $secp_ctx: expr) => {
3226 let privkey = SecretKey::from_slice(&<Vec<u8>>::from_hex($slice).unwrap()[..]).unwrap();
3227 let pubkey = PublicKey::from_secret_key(&$secp_ctx, &privkey);
3233 macro_rules! get_sig_on {
3234 ($privkey: expr, $ctx: expr, $string: expr) => {
3236 let sighash = Message::from_slice(&$string.into_bytes()[..]).unwrap();
3237 $ctx.sign_ecdsa(&sighash, &$privkey)
3243 fn encoding_announcement_signatures() {
3244 let secp_ctx = Secp256k1::new();
3245 let (privkey, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3246 let sig_1 = get_sig_on!(privkey, secp_ctx, String::from("01010101010101010101010101010101"));
3247 let sig_2 = get_sig_on!(privkey, secp_ctx, String::from("02020202020202020202020202020202"));
3248 let announcement_signatures = msgs::AnnouncementSignatures {
3249 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]),
3250 short_channel_id: 2316138423780173,
3251 node_signature: sig_1,
3252 bitcoin_signature: sig_2,
3255 let encoded_value = announcement_signatures.encode();
3256 assert_eq!(encoded_value, <Vec<u8>>::from_hex("040000000000000005000000000000000600000000000000070000000000000000083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073acf9953cef4700860f5967838eba2bae89288ad188ebf8b20bf995c3ea53a26df1876d0a3a0e13172ba286a673140190c02ba9da60a2e43a745188c8a83c7f3ef").unwrap());
3259 fn do_encoding_channel_announcement(unknown_features_bits: bool, excess_data: bool) {
3260 let secp_ctx = Secp256k1::new();
3261 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3262 let (privkey_2, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3263 let (privkey_3, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3264 let (privkey_4, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3265 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3266 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
3267 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
3268 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
3269 let mut features = ChannelFeatures::empty();
3270 if unknown_features_bits {
3271 features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
3273 let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
3275 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3276 short_channel_id: 2316138423780173,
3277 node_id_1: NodeId::from_pubkey(&pubkey_1),
3278 node_id_2: NodeId::from_pubkey(&pubkey_2),
3279 bitcoin_key_1: NodeId::from_pubkey(&pubkey_3),
3280 bitcoin_key_2: NodeId::from_pubkey(&pubkey_4),
3281 excess_data: if excess_data { vec![10, 0, 0, 20, 0, 0, 30, 0, 0, 40] } else { Vec::new() },
3283 let channel_announcement = msgs::ChannelAnnouncement {
3284 node_signature_1: sig_1,
3285 node_signature_2: sig_2,
3286 bitcoin_signature_1: sig_3,
3287 bitcoin_signature_2: sig_4,
3288 contents: unsigned_channel_announcement,
3290 let encoded_value = channel_announcement.encode();
3291 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a1735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap();
3292 if unknown_features_bits {
3293 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3295 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
3297 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3298 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3300 target_value.append(&mut <Vec<u8>>::from_hex("0a00001400001e000028").unwrap());
3302 assert_eq!(encoded_value, target_value);
3306 fn encoding_channel_announcement() {
3307 do_encoding_channel_announcement(true, false);
3308 do_encoding_channel_announcement(false, true);
3309 do_encoding_channel_announcement(false, false);
3310 do_encoding_channel_announcement(true, true);
3313 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) {
3314 let secp_ctx = Secp256k1::new();
3315 let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3316 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3317 let features = if unknown_features_bits {
3318 NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
3320 // Set to some features we may support
3321 NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
3323 let mut addresses = Vec::new();
3325 addresses.push(SocketAddress::TcpIpV4 {
3326 addr: [255, 254, 253, 252],
3331 addresses.push(SocketAddress::TcpIpV6 {
3332 addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
3337 addresses.push(msgs::SocketAddress::OnionV2(
3338 [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]
3342 addresses.push(msgs::SocketAddress::OnionV3 {
3343 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],
3350 addresses.push(SocketAddress::Hostname {
3351 hostname: Hostname::try_from(String::from("host")).unwrap(),
3355 let mut addr_len = 0;
3356 for addr in &addresses {
3357 addr_len += addr.len() + 1;
3359 let unsigned_node_announcement = msgs::UnsignedNodeAnnouncement {
3361 timestamp: 20190119,
3362 node_id: NodeId::from_pubkey(&pubkey_1),
3364 alias: NodeAlias([16;32]),
3366 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() },
3367 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() },
3369 addr_len += unsigned_node_announcement.excess_address_data.len() as u16;
3370 let node_announcement = msgs::NodeAnnouncement {
3372 contents: unsigned_node_announcement,
3374 let encoded_value = node_announcement.encode();
3375 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3376 if unknown_features_bits {
3377 target_value.append(&mut <Vec<u8>>::from_hex("0002ffff").unwrap());
3379 target_value.append(&mut <Vec<u8>>::from_hex("000122").unwrap());
3381 target_value.append(&mut <Vec<u8>>::from_hex("013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010").unwrap());
3382 target_value.append(&mut vec![(addr_len >> 8) as u8, addr_len as u8]);
3384 target_value.append(&mut <Vec<u8>>::from_hex("01fffefdfc2607").unwrap());
3387 target_value.append(&mut <Vec<u8>>::from_hex("02fffefdfcfbfaf9f8f7f6f5f4f3f2f1f02607").unwrap());
3390 target_value.append(&mut <Vec<u8>>::from_hex("03fffefdfcfbfaf9f8f7f62607").unwrap());
3393 target_value.append(&mut <Vec<u8>>::from_hex("04fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e00020102607").unwrap());
3396 target_value.append(&mut <Vec<u8>>::from_hex("0504686f73742607").unwrap());
3398 if excess_address_data {
3399 target_value.append(&mut <Vec<u8>>::from_hex("216c280b5395a2546e7e4b2663e04f811622f15a4f92e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d269").unwrap());
3402 target_value.append(&mut <Vec<u8>>::from_hex("3b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
3404 assert_eq!(encoded_value, target_value);
3408 fn encoding_node_announcement() {
3409 do_encoding_node_announcement(true, true, true, true, true, true, true, true);
3410 do_encoding_node_announcement(false, false, false, false, false, false, false, false);
3411 do_encoding_node_announcement(false, true, false, false, false, false, false, false);
3412 do_encoding_node_announcement(false, false, true, false, false, false, false, false);
3413 do_encoding_node_announcement(false, false, false, true, false, false, false, false);
3414 do_encoding_node_announcement(false, false, false, false, true, false, false, false);
3415 do_encoding_node_announcement(false, false, false, false, false, true, false, false);
3416 do_encoding_node_announcement(false, false, false, false, false, false, true, false);
3417 do_encoding_node_announcement(false, true, false, true, false, false, true, false);
3418 do_encoding_node_announcement(false, false, true, false, true, false, false, false);
3421 fn do_encoding_channel_update(direction: bool, disable: bool, excess_data: bool) {
3422 let secp_ctx = Secp256k1::new();
3423 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3424 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3425 let unsigned_channel_update = msgs::UnsignedChannelUpdate {
3426 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3427 short_channel_id: 2316138423780173,
3428 timestamp: 20190119,
3429 flags: if direction { 1 } else { 0 } | if disable { 1 << 1 } else { 0 },
3430 cltv_expiry_delta: 144,
3431 htlc_minimum_msat: 1000000,
3432 htlc_maximum_msat: 131355275467161,
3433 fee_base_msat: 10000,
3434 fee_proportional_millionths: 20,
3435 excess_data: if excess_data { vec![0, 0, 0, 0, 59, 154, 202, 0] } else { Vec::new() }
3437 let channel_update = msgs::ChannelUpdate {
3439 contents: unsigned_channel_update
3441 let encoded_value = channel_update.encode();
3442 let mut target_value = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3443 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3444 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d013413a7").unwrap());
3445 target_value.append(&mut <Vec<u8>>::from_hex("01").unwrap());
3446 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3448 let flag = target_value.last_mut().unwrap();
3452 let flag = target_value.last_mut().unwrap();
3453 *flag = *flag | 1 << 1;
3455 target_value.append(&mut <Vec<u8>>::from_hex("009000000000000f42400000271000000014").unwrap());
3456 target_value.append(&mut <Vec<u8>>::from_hex("0000777788889999").unwrap());
3458 target_value.append(&mut <Vec<u8>>::from_hex("000000003b9aca00").unwrap());
3460 assert_eq!(encoded_value, target_value);
3464 fn encoding_channel_update() {
3465 do_encoding_channel_update(false, false, false);
3466 do_encoding_channel_update(false, false, true);
3467 do_encoding_channel_update(true, false, false);
3468 do_encoding_channel_update(true, false, true);
3469 do_encoding_channel_update(false, true, false);
3470 do_encoding_channel_update(false, true, true);
3471 do_encoding_channel_update(true, true, false);
3472 do_encoding_channel_update(true, true, true);
3475 fn do_encoding_open_channel(random_bit: bool, shutdown: bool, incl_chan_type: bool) {
3476 let secp_ctx = Secp256k1::new();
3477 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3478 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3479 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3480 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3481 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3482 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3483 let open_channel = msgs::OpenChannel {
3484 common_fields: CommonOpenChannelFields {
3485 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3486 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3487 funding_satoshis: 1311768467284833366,
3488 dust_limit_satoshis: 3608586615801332854,
3489 max_htlc_value_in_flight_msat: 8517154655701053848,
3490 htlc_minimum_msat: 2316138423780173,
3491 commitment_feerate_sat_per_1000_weight: 821716,
3492 to_self_delay: 49340,
3493 max_accepted_htlcs: 49340,
3494 funding_pubkey: pubkey_1,
3495 revocation_basepoint: pubkey_2,
3496 payment_basepoint: pubkey_3,
3497 delayed_payment_basepoint: pubkey_4,
3498 htlc_basepoint: pubkey_5,
3499 first_per_commitment_point: pubkey_6,
3500 channel_flags: if random_bit { 1 << 5 } else { 0 },
3501 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3502 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3504 push_msat: 2536655962884945560,
3505 channel_reserve_satoshis: 8665828695742877976,
3507 let encoded_value = open_channel.encode();
3508 let mut target_value = Vec::new();
3509 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3510 target_value.append(&mut <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202021234567890123456233403289122369832144668701144767633030896203198784335490624111800083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3512 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3514 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3517 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3520 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3522 assert_eq!(encoded_value, target_value);
3526 fn encoding_open_channel() {
3527 do_encoding_open_channel(false, false, false);
3528 do_encoding_open_channel(false, false, true);
3529 do_encoding_open_channel(false, true, false);
3530 do_encoding_open_channel(false, true, true);
3531 do_encoding_open_channel(true, false, false);
3532 do_encoding_open_channel(true, false, true);
3533 do_encoding_open_channel(true, true, false);
3534 do_encoding_open_channel(true, true, true);
3537 fn do_encoding_open_channelv2(random_bit: bool, shutdown: bool, incl_chan_type: bool, require_confirmed_inputs: bool) {
3538 let secp_ctx = Secp256k1::new();
3539 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3540 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3541 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3542 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3543 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3544 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3545 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3546 let open_channelv2 = msgs::OpenChannelV2 {
3547 common_fields: CommonOpenChannelFields {
3548 chain_hash: ChainHash::using_genesis_block(Network::Bitcoin),
3549 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3550 commitment_feerate_sat_per_1000_weight: 821716,
3551 funding_satoshis: 1311768467284833366,
3552 dust_limit_satoshis: 3608586615801332854,
3553 max_htlc_value_in_flight_msat: 8517154655701053848,
3554 htlc_minimum_msat: 2316138423780173,
3555 to_self_delay: 49340,
3556 max_accepted_htlcs: 49340,
3557 funding_pubkey: pubkey_1,
3558 revocation_basepoint: pubkey_2,
3559 payment_basepoint: pubkey_3,
3560 delayed_payment_basepoint: pubkey_4,
3561 htlc_basepoint: pubkey_5,
3562 first_per_commitment_point: pubkey_6,
3563 channel_flags: if random_bit { 1 << 5 } else { 0 },
3564 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3565 channel_type: if incl_chan_type { Some(ChannelTypeFeatures::empty()) } else { None },
3567 funding_feerate_sat_per_1000_weight: 821716,
3568 locktime: 305419896,
3569 second_per_commitment_point: pubkey_7,
3570 require_confirmed_inputs: if require_confirmed_inputs { Some(()) } else { None },
3572 let encoded_value = open_channelv2.encode();
3573 let mut target_value = Vec::new();
3574 target_value.append(&mut <Vec<u8>>::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
3575 target_value.append(&mut <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap());
3576 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3577 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap());
3578 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap());
3579 target_value.append(&mut <Vec<u8>>::from_hex("3214466870114476").unwrap());
3580 target_value.append(&mut <Vec<u8>>::from_hex("7633030896203198").unwrap());
3581 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap());
3582 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3583 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap());
3584 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap());
3585 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap());
3586 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap());
3587 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap());
3588 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap());
3589 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap());
3590 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap());
3591 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap());
3594 target_value.append(&mut <Vec<u8>>::from_hex("20").unwrap());
3596 target_value.append(&mut <Vec<u8>>::from_hex("00").unwrap());
3599 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3602 target_value.append(&mut <Vec<u8>>::from_hex("0100").unwrap());
3604 if require_confirmed_inputs {
3605 target_value.append(&mut <Vec<u8>>::from_hex("0200").unwrap());
3607 assert_eq!(encoded_value, target_value);
3611 fn encoding_open_channelv2() {
3612 do_encoding_open_channelv2(false, false, false, false);
3613 do_encoding_open_channelv2(false, false, false, true);
3614 do_encoding_open_channelv2(false, false, true, false);
3615 do_encoding_open_channelv2(false, false, true, true);
3616 do_encoding_open_channelv2(false, true, false, false);
3617 do_encoding_open_channelv2(false, true, false, true);
3618 do_encoding_open_channelv2(false, true, true, false);
3619 do_encoding_open_channelv2(false, true, true, true);
3620 do_encoding_open_channelv2(true, false, false, false);
3621 do_encoding_open_channelv2(true, false, false, true);
3622 do_encoding_open_channelv2(true, false, true, false);
3623 do_encoding_open_channelv2(true, false, true, true);
3624 do_encoding_open_channelv2(true, true, false, false);
3625 do_encoding_open_channelv2(true, true, false, true);
3626 do_encoding_open_channelv2(true, true, true, false);
3627 do_encoding_open_channelv2(true, true, true, true);
3630 fn do_encoding_accept_channel(shutdown: bool) {
3631 let secp_ctx = Secp256k1::new();
3632 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3633 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3634 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3635 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3636 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3637 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3638 let accept_channel = msgs::AcceptChannel {
3639 common_fields: CommonAcceptChannelFields {
3640 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3641 dust_limit_satoshis: 1311768467284833366,
3642 max_htlc_value_in_flight_msat: 2536655962884945560,
3643 htlc_minimum_msat: 2316138423780173,
3644 minimum_depth: 821716,
3645 to_self_delay: 49340,
3646 max_accepted_htlcs: 49340,
3647 funding_pubkey: pubkey_1,
3648 revocation_basepoint: pubkey_2,
3649 payment_basepoint: pubkey_3,
3650 delayed_payment_basepoint: pubkey_4,
3651 htlc_basepoint: pubkey_5,
3652 first_per_commitment_point: pubkey_6,
3653 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3656 channel_reserve_satoshis: 3608586615801332854,
3658 next_local_nonce: None,
3660 let encoded_value = accept_channel.encode();
3661 let mut target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020212345678901234562334032891223698321446687011447600083a840000034d000c89d4c0bcc0bc031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d076602531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe33703462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f703f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap();
3663 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3665 assert_eq!(encoded_value, target_value);
3669 fn encoding_accept_channel() {
3670 do_encoding_accept_channel(false);
3671 do_encoding_accept_channel(true);
3674 fn do_encoding_accept_channelv2(shutdown: bool) {
3675 let secp_ctx = Secp256k1::new();
3676 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3677 let (_, pubkey_2) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
3678 let (_, pubkey_3) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
3679 let (_, pubkey_4) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
3680 let (_, pubkey_5) = get_keys_from!("0505050505050505050505050505050505050505050505050505050505050505", secp_ctx);
3681 let (_, pubkey_6) = get_keys_from!("0606060606060606060606060606060606060606060606060606060606060606", secp_ctx);
3682 let (_, pubkey_7) = get_keys_from!("0707070707070707070707070707070707070707070707070707070707070707", secp_ctx);
3683 let accept_channelv2 = msgs::AcceptChannelV2 {
3684 common_fields: CommonAcceptChannelFields {
3685 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3686 dust_limit_satoshis: 1311768467284833366,
3687 max_htlc_value_in_flight_msat: 2536655962884945560,
3688 htlc_minimum_msat: 2316138423780173,
3689 minimum_depth: 821716,
3690 to_self_delay: 49340,
3691 max_accepted_htlcs: 49340,
3692 funding_pubkey: pubkey_1,
3693 revocation_basepoint: pubkey_2,
3694 payment_basepoint: pubkey_3,
3695 delayed_payment_basepoint: pubkey_4,
3696 htlc_basepoint: pubkey_5,
3697 first_per_commitment_point: pubkey_6,
3698 shutdown_scriptpubkey: if shutdown { Some(Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey()) } else { None },
3701 funding_satoshis: 1311768467284833366,
3702 second_per_commitment_point: pubkey_7,
3703 require_confirmed_inputs: None,
3705 let encoded_value = accept_channelv2.encode();
3706 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // temporary_channel_id
3707 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // funding_satoshis
3708 target_value.append(&mut <Vec<u8>>::from_hex("1234567890123456").unwrap()); // dust_limit_satoshis
3709 target_value.append(&mut <Vec<u8>>::from_hex("2334032891223698").unwrap()); // max_htlc_value_in_flight_msat
3710 target_value.append(&mut <Vec<u8>>::from_hex("00083a840000034d").unwrap()); // htlc_minimum_msat
3711 target_value.append(&mut <Vec<u8>>::from_hex("000c89d4").unwrap()); // minimum_depth
3712 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // to_self_delay
3713 target_value.append(&mut <Vec<u8>>::from_hex("c0bc").unwrap()); // max_accepted_htlcs
3714 target_value.append(&mut <Vec<u8>>::from_hex("031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap()); // funding_pubkey
3715 target_value.append(&mut <Vec<u8>>::from_hex("024d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d0766").unwrap()); // revocation_basepoint
3716 target_value.append(&mut <Vec<u8>>::from_hex("02531fe6068134503d2723133227c867ac8fa6c83c537e9a44c3c5bdbdcb1fe337").unwrap()); // payment_basepoint
3717 target_value.append(&mut <Vec<u8>>::from_hex("03462779ad4aad39514614751a71085f2f10e1c7a593e4e030efb5b8721ce55b0b").unwrap()); // delayed_payment_basepoint
3718 target_value.append(&mut <Vec<u8>>::from_hex("0362c0a046dacce86ddd0343c6d3c7c79c2208ba0d9c9cf24a6d046d21d21f90f7").unwrap()); // htlc_basepoint
3719 target_value.append(&mut <Vec<u8>>::from_hex("03f006a18d5653c4edf5391ff23a61f03ff83d237e880ee61187fa9f379a028e0a").unwrap()); // first_per_commitment_point
3720 target_value.append(&mut <Vec<u8>>::from_hex("02989c0b76cb563971fdc9bef31ec06c3560f3249d6ee9e5d83c57625596e05f6f").unwrap()); // second_per_commitment_point
3722 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
3724 assert_eq!(encoded_value, target_value);
3728 fn encoding_accept_channelv2() {
3729 do_encoding_accept_channelv2(false);
3730 do_encoding_accept_channelv2(true);
3734 fn encoding_funding_created() {
3735 let secp_ctx = Secp256k1::new();
3736 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3737 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3738 let funding_created = msgs::FundingCreated {
3739 temporary_channel_id: ChannelId::from_bytes([2; 32]),
3740 funding_txid: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3741 funding_output_index: 255,
3744 partial_signature_with_nonce: None,
3746 next_local_nonce: None,
3748 let encoded_value = funding_created.encode();
3749 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202026e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c200ffd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3750 assert_eq!(encoded_value, target_value);
3754 fn encoding_funding_signed() {
3755 let secp_ctx = Secp256k1::new();
3756 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3757 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
3758 let funding_signed = msgs::FundingSigned {
3759 channel_id: ChannelId::from_bytes([2; 32]),
3762 partial_signature_with_nonce: None,
3764 let encoded_value = funding_signed.encode();
3765 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
3766 assert_eq!(encoded_value, target_value);
3770 fn encoding_channel_ready() {
3771 let secp_ctx = Secp256k1::new();
3772 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3773 let channel_ready = msgs::ChannelReady {
3774 channel_id: ChannelId::from_bytes([2; 32]),
3775 next_per_commitment_point: pubkey_1,
3776 short_channel_id_alias: None,
3778 let encoded_value = channel_ready.encode();
3779 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
3780 assert_eq!(encoded_value, target_value);
3784 fn encoding_splice() {
3785 let secp_ctx = Secp256k1::new();
3786 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3787 let splice = msgs::Splice {
3788 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3789 channel_id: ChannelId::from_bytes([2; 32]),
3790 relative_satoshis: 123456,
3791 funding_feerate_perkw: 2000,
3793 funding_pubkey: pubkey_1,
3795 let encoded_value = splice.encode();
3796 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240000007d000000000031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3800 fn encoding_stfu() {
3801 let stfu = msgs::Stfu {
3802 channel_id: ChannelId::from_bytes([2; 32]),
3805 let encoded_value = stfu.encode();
3806 assert_eq!(encoded_value.as_hex().to_string(), "020202020202020202020202020202020202020202020202020202020202020201");
3810 fn encoding_splice_ack() {
3811 let secp_ctx = Secp256k1::new();
3812 let (_, pubkey_1,) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
3813 let splice = msgs::SpliceAck {
3814 chain_hash: ChainHash::from_hex("6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap(),
3815 channel_id: ChannelId::from_bytes([2; 32]),
3816 relative_satoshis: 123456,
3817 funding_pubkey: pubkey_1,
3819 let encoded_value = splice.encode();
3820 assert_eq!(encoded_value.as_hex().to_string(), "02020202020202020202020202020202020202020202020202020202020202026fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000000000000001e240031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f");
3824 fn encoding_splice_locked() {
3825 let splice = msgs::SpliceLocked {
3826 channel_id: ChannelId::from_bytes([2; 32]),
3828 let encoded_value = splice.encode();
3829 assert_eq!(encoded_value.as_hex().to_string(), "0202020202020202020202020202020202020202020202020202020202020202");
3833 fn encoding_tx_add_input() {
3834 let tx_add_input = msgs::TxAddInput {
3835 channel_id: ChannelId::from_bytes([2; 32]),
3836 serial_id: 4886718345,
3837 prevtx: TransactionU16LenLimited::new(Transaction {
3839 lock_time: LockTime::ZERO,
3841 previous_output: OutPoint { txid: Txid::from_str("305bab643ee297b8b6b76b320792c8223d55082122cb606bf89382146ced9c77").unwrap(), index: 2 }.into_bitcoin_outpoint(),
3842 script_sig: ScriptBuf::new(),
3843 sequence: Sequence(0xfffffffd),
3844 witness: Witness::from_slice(&vec![
3845 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3846 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3851 script_pubkey: Address::from_str("bc1qzlffunw52jav8vwdu5x3jfk6sr8u22rmq3xzw2").unwrap().payload.script_pubkey(),
3855 script_pubkey: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3859 prevtx_out: 305419896,
3860 sequence: 305419896,
3862 let encoded_value = tx_add_input.encode();
3863 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900de02000000000101779ced6c148293f86b60cb222108553d22c89207326bb7b6b897e23e64ab5b300200000000fdffffff0236dbc1000000000016001417d29e4dd454bac3b1cde50d1926da80cfc5287b9cbd03000000000016001436ec78d514df462da95e6a00c24daa8915362d420247304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701210301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944000000001234567812345678").unwrap();
3864 assert_eq!(encoded_value, target_value);
3868 fn encoding_tx_add_output() {
3869 let tx_add_output = msgs::TxAddOutput {
3870 channel_id: ChannelId::from_bytes([2; 32]),
3871 serial_id: 4886718345,
3873 script: Address::from_str("bc1qxmk834g5marzm227dgqvynd23y2nvt2ztwcw2z").unwrap().payload.script_pubkey(),
3875 let encoded_value = tx_add_output.encode();
3876 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000000012345678900000001234567890016001436ec78d514df462da95e6a00c24daa8915362d42").unwrap();
3877 assert_eq!(encoded_value, target_value);
3881 fn encoding_tx_remove_input() {
3882 let tx_remove_input = msgs::TxRemoveInput {
3883 channel_id: ChannelId::from_bytes([2; 32]),
3884 serial_id: 4886718345,
3886 let encoded_value = tx_remove_input.encode();
3887 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3888 assert_eq!(encoded_value, target_value);
3892 fn encoding_tx_remove_output() {
3893 let tx_remove_output = msgs::TxRemoveOutput {
3894 channel_id: ChannelId::from_bytes([2; 32]),
3895 serial_id: 4886718345,
3897 let encoded_value = tx_remove_output.encode();
3898 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020000000123456789").unwrap();
3899 assert_eq!(encoded_value, target_value);
3903 fn encoding_tx_complete() {
3904 let tx_complete = msgs::TxComplete {
3905 channel_id: ChannelId::from_bytes([2; 32]),
3907 let encoded_value = tx_complete.encode();
3908 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3909 assert_eq!(encoded_value, target_value);
3913 fn encoding_tx_signatures() {
3914 let tx_signatures = msgs::TxSignatures {
3915 channel_id: ChannelId::from_bytes([2; 32]),
3916 tx_hash: Txid::from_str("c2d4449afa8d26140898dd54d3390b057ba2a5afcf03ba29d7dc0d8b9ffe966e").unwrap(),
3918 Witness::from_slice(&vec![
3919 <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap(),
3920 <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap()]),
3921 Witness::from_slice(&vec![
3922 <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap(),
3923 <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap()]),
3926 let encoded_value = tx_signatures.encode();
3927 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3928 target_value.append(&mut <Vec<u8>>::from_hex("6e96fe9f8b0ddcd729ba03cfafa5a27b050b39d354dd980814268dfa9a44d4c2").unwrap()); // tx_hash (sha256) (big endian byte order)
3929 target_value.append(&mut <Vec<u8>>::from_hex("0002").unwrap()); // num_witnesses (u16)
3931 target_value.append(&mut <Vec<u8>>::from_hex("006b").unwrap()); // len of witness_data
3932 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3933 target_value.append(&mut <Vec<u8>>::from_hex("47").unwrap()); // len of witness element data (VarInt)
3934 target_value.append(&mut <Vec<u8>>::from_hex("304402206af85b7dd67450ad12c979302fac49dfacbc6a8620f49c5da2b5721cf9565ca502207002b32fed9ce1bf095f57aeb10c36928ac60b12e723d97d2964a54640ceefa701").unwrap());
3935 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3936 target_value.append(&mut <Vec<u8>>::from_hex("0301ab7dc16488303549bfcdd80f6ae5ee4c20bf97ab5410bbd6b1bfa85dcd6944").unwrap());
3938 target_value.append(&mut <Vec<u8>>::from_hex("006c").unwrap()); // len of witness_data
3939 target_value.append(&mut <Vec<u8>>::from_hex("02").unwrap()); // num_witness_elements (VarInt)
3940 target_value.append(&mut <Vec<u8>>::from_hex("48").unwrap()); // len of witness element data (VarInt)
3941 target_value.append(&mut <Vec<u8>>::from_hex("3045022100ee00dbf4a862463e837d7c08509de814d620e4d9830fa84818713e0fa358f145022021c3c7060c4d53fe84fd165d60208451108a778c13b92ca4c6bad439236126cc01").unwrap());
3942 target_value.append(&mut <Vec<u8>>::from_hex("21").unwrap()); // len of witness element data (VarInt)
3943 target_value.append(&mut <Vec<u8>>::from_hex("028fbbf0b16f5ba5bcb5dd37cd4047ce6f726a21c06682f9ec2f52b057de1dbdb5").unwrap());
3944 assert_eq!(encoded_value, target_value);
3947 fn do_encoding_tx_init_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3948 let tx_init_rbf = msgs::TxInitRbf {
3949 channel_id: ChannelId::from_bytes([2; 32]),
3950 locktime: 305419896,
3951 feerate_sat_per_1000_weight: 20190119,
3952 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3954 let encoded_value = tx_init_rbf.encode();
3955 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap(); // channel_id
3956 target_value.append(&mut <Vec<u8>>::from_hex("12345678").unwrap()); // locktime
3957 target_value.append(&mut <Vec<u8>>::from_hex("013413a7").unwrap()); // feerate_sat_per_1000_weight
3958 if let Some((_, target)) = funding_value_with_hex_target {
3959 target_value.push(0x00); // Type
3960 target_value.push(target.len() as u8 / 2); // Length
3961 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3963 assert_eq!(encoded_value, target_value);
3967 fn encoding_tx_init_rbf() {
3968 do_encoding_tx_init_rbf(Some((1311768467284833366, "1234567890123456")));
3969 do_encoding_tx_init_rbf(Some((13117684672, "000000030DDFFBC0")));
3970 do_encoding_tx_init_rbf(None);
3973 fn do_encoding_tx_ack_rbf(funding_value_with_hex_target: Option<(i64, &str)>) {
3974 let tx_ack_rbf = msgs::TxAckRbf {
3975 channel_id: ChannelId::from_bytes([2; 32]),
3976 funding_output_contribution: if let Some((value, _)) = funding_value_with_hex_target { Some(value) } else { None },
3978 let encoded_value = tx_ack_rbf.encode();
3979 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
3980 if let Some((_, target)) = funding_value_with_hex_target {
3981 target_value.push(0x00); // Type
3982 target_value.push(target.len() as u8 / 2); // Length
3983 target_value.append(&mut <Vec<u8>>::from_hex(target).unwrap()); // Value (i64)
3985 assert_eq!(encoded_value, target_value);
3989 fn encoding_tx_ack_rbf() {
3990 do_encoding_tx_ack_rbf(Some((1311768467284833366, "1234567890123456")));
3991 do_encoding_tx_ack_rbf(Some((13117684672, "000000030DDFFBC0")));
3992 do_encoding_tx_ack_rbf(None);
3996 fn encoding_tx_abort() {
3997 let tx_abort = msgs::TxAbort {
3998 channel_id: ChannelId::from_bytes([2; 32]),
3999 data: <Vec<u8>>::from_hex("54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap(),
4001 let encoded_value = tx_abort.encode();
4002 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202002C54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F672E").unwrap();
4003 assert_eq!(encoded_value, target_value);
4006 fn do_encoding_shutdown(script_type: u8) {
4007 let secp_ctx = Secp256k1::new();
4008 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4009 let script = Builder::new().push_opcode(opcodes::OP_TRUE).into_script();
4010 let shutdown = msgs::Shutdown {
4011 channel_id: ChannelId::from_bytes([2; 32]),
4013 if script_type == 1 { Address::p2pkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).script_pubkey() }
4014 else if script_type == 2 { Address::p2sh(&script, Network::Testnet).unwrap().script_pubkey() }
4015 else if script_type == 3 { Address::p2wpkh(&::bitcoin::PublicKey{compressed: true, inner: pubkey_1}, Network::Testnet).unwrap().script_pubkey() }
4016 else { Address::p2wsh(&script, Network::Testnet).script_pubkey() },
4018 let encoded_value = shutdown.encode();
4019 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap();
4020 if script_type == 1 {
4021 target_value.append(&mut <Vec<u8>>::from_hex("001976a91479b000887626b294a914501a4cd226b58b23598388ac").unwrap());
4022 } else if script_type == 2 {
4023 target_value.append(&mut <Vec<u8>>::from_hex("0017a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87").unwrap());
4024 } else if script_type == 3 {
4025 target_value.append(&mut <Vec<u8>>::from_hex("0016001479b000887626b294a914501a4cd226b58b235983").unwrap());
4026 } else if script_type == 4 {
4027 target_value.append(&mut <Vec<u8>>::from_hex("002200204ae81572f06e1b88fd5ced7a1a000945432e83e1551e6f721ee9c00b8cc33260").unwrap());
4029 assert_eq!(encoded_value, target_value);
4033 fn encoding_shutdown() {
4034 do_encoding_shutdown(1);
4035 do_encoding_shutdown(2);
4036 do_encoding_shutdown(3);
4037 do_encoding_shutdown(4);
4041 fn encoding_closing_signed() {
4042 let secp_ctx = Secp256k1::new();
4043 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4044 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4045 let closing_signed = msgs::ClosingSigned {
4046 channel_id: ChannelId::from_bytes([2; 32]),
4047 fee_satoshis: 2316138423780173,
4051 let encoded_value = closing_signed.encode();
4052 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4053 assert_eq!(encoded_value, target_value);
4054 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value)).unwrap(), closing_signed);
4056 let closing_signed_with_range = msgs::ClosingSigned {
4057 channel_id: ChannelId::from_bytes([2; 32]),
4058 fee_satoshis: 2316138423780173,
4060 fee_range: Some(msgs::ClosingSignedFeeRange {
4061 min_fee_satoshis: 0xdeadbeef,
4062 max_fee_satoshis: 0x1badcafe01234567,
4065 let encoded_value_with_range = closing_signed_with_range.encode();
4066 let target_value_with_range = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034dd977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a011000000000deadbeef1badcafe01234567").unwrap();
4067 assert_eq!(encoded_value_with_range, target_value_with_range);
4068 assert_eq!(msgs::ClosingSigned::read(&mut Cursor::new(&target_value_with_range)).unwrap(),
4069 closing_signed_with_range);
4073 fn encoding_update_add_htlc() {
4074 let secp_ctx = Secp256k1::new();
4075 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4076 let onion_routing_packet = msgs::OnionPacket {
4078 public_key: Ok(pubkey_1),
4079 hop_data: [1; 20*65],
4082 let update_add_htlc = msgs::UpdateAddHTLC {
4083 channel_id: ChannelId::from_bytes([2; 32]),
4084 htlc_id: 2316138423780173,
4085 amount_msat: 3608586615801332854,
4086 payment_hash: PaymentHash([1; 32]),
4087 cltv_expiry: 821716,
4088 onion_routing_packet,
4089 skimmed_fee_msat: None,
4090 blinding_point: None,
4092 let encoded_value = update_add_htlc.encode();
4093 let target_value = <Vec<u8>>::from_hex("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").unwrap();
4094 assert_eq!(encoded_value, target_value);
4098 fn encoding_update_fulfill_htlc() {
4099 let update_fulfill_htlc = msgs::UpdateFulfillHTLC {
4100 channel_id: ChannelId::from_bytes([2; 32]),
4101 htlc_id: 2316138423780173,
4102 payment_preimage: PaymentPreimage([1; 32]),
4104 let encoded_value = update_fulfill_htlc.encode();
4105 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d0101010101010101010101010101010101010101010101010101010101010101").unwrap();
4106 assert_eq!(encoded_value, target_value);
4110 fn encoding_update_fail_htlc() {
4111 let reason = OnionErrorPacket {
4112 data: [1; 32].to_vec(),
4114 let update_fail_htlc = msgs::UpdateFailHTLC {
4115 channel_id: ChannelId::from_bytes([2; 32]),
4116 htlc_id: 2316138423780173,
4119 let encoded_value = update_fail_htlc.encode();
4120 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d00200101010101010101010101010101010101010101010101010101010101010101").unwrap();
4121 assert_eq!(encoded_value, target_value);
4125 fn encoding_update_fail_malformed_htlc() {
4126 let update_fail_malformed_htlc = msgs::UpdateFailMalformedHTLC {
4127 channel_id: ChannelId::from_bytes([2; 32]),
4128 htlc_id: 2316138423780173,
4129 sha256_of_onion: [1; 32],
4132 let encoded_value = update_fail_malformed_htlc.encode();
4133 let target_value = <Vec<u8>>::from_hex("020202020202020202020202020202020202020202020202020202020202020200083a840000034d010101010101010101010101010101010101010101010101010101010101010100ff").unwrap();
4134 assert_eq!(encoded_value, target_value);
4137 fn do_encoding_commitment_signed(htlcs: bool) {
4138 let secp_ctx = Secp256k1::new();
4139 let (privkey_1, _) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4140 let (privkey_2, _) = get_keys_from!("0202020202020202020202020202020202020202020202020202020202020202", secp_ctx);
4141 let (privkey_3, _) = get_keys_from!("0303030303030303030303030303030303030303030303030303030303030303", secp_ctx);
4142 let (privkey_4, _) = get_keys_from!("0404040404040404040404040404040404040404040404040404040404040404", secp_ctx);
4143 let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
4144 let sig_2 = get_sig_on!(privkey_2, secp_ctx, String::from("01010101010101010101010101010101"));
4145 let sig_3 = get_sig_on!(privkey_3, secp_ctx, String::from("01010101010101010101010101010101"));
4146 let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
4147 let commitment_signed = msgs::CommitmentSigned {
4148 channel_id: ChannelId::from_bytes([2; 32]),
4150 htlc_signatures: if htlcs { vec![sig_2, sig_3, sig_4] } else { Vec::new() },
4152 partial_signature_with_nonce: None,
4154 let encoded_value = commitment_signed.encode();
4155 let mut target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a").unwrap();
4157 target_value.append(&mut <Vec<u8>>::from_hex("00031735b6a427e80d5fe7cd90a2f4ee08dc9c27cda7c35a4172e5d85b12c49d4232537e98f9b1f3c5e6989a8b9644e90e8918127680dbd0d4043510840fc0f1e11a216c280b5395a2546e7e4b2663e04f811622f15a4f91e83aa2e92ba2a573c139142c54ae63072a1ec1ee7dc0c04bde5c847806172aa05c92c22ae8e308d1d2692b12cc195ce0a2d1bda6a88befa19fa07f51caa75ce83837f28965600b8aacab0855ffb0e741ec5f7c41421e9829a9d48611c8c831f71be5ea73e66594977ffd").unwrap());
4159 target_value.append(&mut <Vec<u8>>::from_hex("0000").unwrap());
4161 assert_eq!(encoded_value, target_value);
4165 fn encoding_commitment_signed() {
4166 do_encoding_commitment_signed(true);
4167 do_encoding_commitment_signed(false);
4171 fn encoding_revoke_and_ack() {
4172 let secp_ctx = Secp256k1::new();
4173 let (_, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4174 let raa = msgs::RevokeAndACK {
4175 channel_id: ChannelId::from_bytes([2; 32]),
4176 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],
4177 next_per_commitment_point: pubkey_1,
4179 next_local_nonce: None,
4181 let encoded_value = raa.encode();
4182 let target_value = <Vec<u8>>::from_hex("02020202020202020202020202020202020202020202020202020202020202020101010101010101010101010101010101010101010101010101010101010101031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f").unwrap();
4183 assert_eq!(encoded_value, target_value);
4187 fn encoding_update_fee() {
4188 let update_fee = msgs::UpdateFee {
4189 channel_id: ChannelId::from_bytes([2; 32]),
4190 feerate_per_kw: 20190119,
4192 let encoded_value = update_fee.encode();
4193 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202013413a7").unwrap();
4194 assert_eq!(encoded_value, target_value);
4198 fn encoding_init() {
4199 let mainnet_hash = ChainHash::using_genesis_block(Network::Bitcoin);
4200 assert_eq!(msgs::Init {
4201 features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
4202 networks: Some(vec![mainnet_hash]),
4203 remote_network_address: None,
4204 }.encode(), <Vec<u8>>::from_hex("00023fff0003ffffff01206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4205 assert_eq!(msgs::Init {
4206 features: InitFeatures::from_le_bytes(vec![0xFF]),
4208 remote_network_address: None,
4209 }.encode(), <Vec<u8>>::from_hex("0001ff0001ff").unwrap());
4210 assert_eq!(msgs::Init {
4211 features: InitFeatures::from_le_bytes(vec![]),
4212 networks: Some(vec![mainnet_hash]),
4213 remote_network_address: None,
4214 }.encode(), <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000").unwrap());
4215 assert_eq!(msgs::Init {
4216 features: InitFeatures::from_le_bytes(vec![]),
4217 networks: Some(vec![ChainHash::from(&[1; 32]), ChainHash::from(&[2; 32])]),
4218 remote_network_address: None,
4219 }.encode(), <Vec<u8>>::from_hex("00000000014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202").unwrap());
4220 let init_msg = msgs::Init { features: InitFeatures::from_le_bytes(vec![]),
4221 networks: Some(vec![mainnet_hash]),
4222 remote_network_address: Some(SocketAddress::TcpIpV4 {
4223 addr: [127, 0, 0, 1],
4227 let encoded_value = init_msg.encode();
4228 let target_value = <Vec<u8>>::from_hex("0000000001206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d61900000000000307017f00000103e8").unwrap();
4229 assert_eq!(encoded_value, target_value);
4230 assert_eq!(msgs::Init::read(&mut Cursor::new(&target_value)).unwrap(), init_msg);
4234 fn encoding_error() {
4235 let error = msgs::ErrorMessage {
4236 channel_id: ChannelId::from_bytes([2; 32]),
4237 data: String::from("rust-lightning"),
4239 let encoded_value = error.encode();
4240 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4241 assert_eq!(encoded_value, target_value);
4245 fn encoding_warning() {
4246 let error = msgs::WarningMessage {
4247 channel_id: ChannelId::from_bytes([2; 32]),
4248 data: String::from("rust-lightning"),
4250 let encoded_value = error.encode();
4251 let target_value = <Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202000e727573742d6c696768746e696e67").unwrap();
4252 assert_eq!(encoded_value, target_value);
4256 fn encoding_ping() {
4257 let ping = msgs::Ping {
4261 let encoded_value = ping.encode();
4262 let target_value = <Vec<u8>>::from_hex("0040004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4263 assert_eq!(encoded_value, target_value);
4267 fn encoding_pong() {
4268 let pong = msgs::Pong {
4271 let encoded_value = pong.encode();
4272 let target_value = <Vec<u8>>::from_hex("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
4273 assert_eq!(encoded_value, target_value);
4277 fn encoding_nonfinal_onion_hop_data() {
4278 let outbound_msg = msgs::OutboundOnionPayload::Forward {
4279 short_channel_id: 0xdeadbeef1bad1dea,
4280 amt_to_forward: 0x0badf00d01020304,
4281 outgoing_cltv_value: 0xffffffff,
4283 let encoded_value = outbound_msg.encode();
4284 let target_value = <Vec<u8>>::from_hex("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
4285 assert_eq!(encoded_value, target_value);
4287 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4288 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4289 if let msgs::InboundOnionPayload::Forward {
4290 short_channel_id, amt_to_forward, outgoing_cltv_value
4292 assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
4293 assert_eq!(amt_to_forward, 0x0badf00d01020304);
4294 assert_eq!(outgoing_cltv_value, 0xffffffff);
4295 } else { panic!(); }
4299 fn encoding_final_onion_hop_data() {
4300 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4302 payment_metadata: None,
4303 keysend_preimage: None,
4304 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4305 cltv_expiry_height: 0xffffffff,
4306 custom_tlvs: vec![],
4308 let encoded_value = outbound_msg.encode();
4309 let target_value = <Vec<u8>>::from_hex("1002080badf00d010203040404ffffffff").unwrap();
4310 assert_eq!(encoded_value, target_value);
4312 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4313 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4314 if let msgs::InboundOnionPayload::Receive {
4315 payment_data: None, sender_intended_htlc_amt_msat, cltv_expiry_height, ..
4317 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4318 assert_eq!(cltv_expiry_height, 0xffffffff);
4319 } else { panic!(); }
4323 fn encoding_final_onion_hop_data_with_secret() {
4324 let expected_payment_secret = PaymentSecret([0x42u8; 32]);
4325 let outbound_msg = msgs::OutboundOnionPayload::Receive {
4326 payment_data: Some(FinalOnionHopData {
4327 payment_secret: expected_payment_secret,
4328 total_msat: 0x1badca1f
4330 payment_metadata: None,
4331 keysend_preimage: None,
4332 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4333 cltv_expiry_height: 0xffffffff,
4334 custom_tlvs: vec![],
4336 let encoded_value = outbound_msg.encode();
4337 let target_value = <Vec<u8>>::from_hex("3602080badf00d010203040404ffffffff082442424242424242424242424242424242424242424242424242424242424242421badca1f").unwrap();
4338 assert_eq!(encoded_value, target_value);
4340 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4341 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4342 if let msgs::InboundOnionPayload::Receive {
4343 payment_data: Some(FinalOnionHopData {
4345 total_msat: 0x1badca1f
4347 sender_intended_htlc_amt_msat, cltv_expiry_height,
4348 payment_metadata: None,
4349 keysend_preimage: None,
4352 assert_eq!(payment_secret, expected_payment_secret);
4353 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4354 assert_eq!(cltv_expiry_height, 0xffffffff);
4355 assert_eq!(custom_tlvs, vec![]);
4356 } else { panic!(); }
4360 fn encoding_final_onion_hop_data_with_bad_custom_tlvs() {
4361 // If custom TLVs have type number within the range reserved for protocol, treat them as if
4363 let bad_type_range_tlvs = vec![
4364 ((1 << 16) - 4, vec![42]),
4365 ((1 << 16) - 2, vec![42; 32]),
4367 let mut msg = msgs::OutboundOnionPayload::Receive {
4369 payment_metadata: None,
4370 keysend_preimage: None,
4371 custom_tlvs: bad_type_range_tlvs,
4372 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4373 cltv_expiry_height: 0xffffffff,
4375 let encoded_value = msg.encode();
4376 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4377 assert!(msgs::InboundOnionPayload::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).is_err());
4378 let good_type_range_tlvs = vec![
4379 ((1 << 16) - 3, vec![42]),
4380 ((1 << 16) - 1, vec![42; 32]),
4382 if let msgs::OutboundOnionPayload::Receive { ref mut custom_tlvs, .. } = msg {
4383 *custom_tlvs = good_type_range_tlvs.clone();
4385 let encoded_value = msg.encode();
4386 let inbound_msg = ReadableArgs::read(&mut Cursor::new(&encoded_value[..]), (None, &&node_signer)).unwrap();
4388 msgs::InboundOnionPayload::Receive { custom_tlvs, .. } => assert!(custom_tlvs.is_empty()),
4394 fn encoding_final_onion_hop_data_with_custom_tlvs() {
4395 let expected_custom_tlvs = vec![
4396 (5482373483, vec![0x12, 0x34]),
4397 (5482373487, vec![0x42u8; 8]),
4399 let msg = msgs::OutboundOnionPayload::Receive {
4401 payment_metadata: None,
4402 keysend_preimage: None,
4403 custom_tlvs: expected_custom_tlvs.clone(),
4404 sender_intended_htlc_amt_msat: 0x0badf00d01020304,
4405 cltv_expiry_height: 0xffffffff,
4407 let encoded_value = msg.encode();
4408 let target_value = <Vec<u8>>::from_hex("2e02080badf00d010203040404ffffffffff0000000146c6616b021234ff0000000146c6616f084242424242424242").unwrap();
4409 assert_eq!(encoded_value, target_value);
4410 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4411 let inbound_msg: msgs::InboundOnionPayload = ReadableArgs::read(&mut Cursor::new(&target_value[..]), (None, &&node_signer)).unwrap();
4412 if let msgs::InboundOnionPayload::Receive {
4414 payment_metadata: None,
4415 keysend_preimage: None,
4417 sender_intended_htlc_amt_msat,
4418 cltv_expiry_height: outgoing_cltv_value,
4421 assert_eq!(custom_tlvs, expected_custom_tlvs);
4422 assert_eq!(sender_intended_htlc_amt_msat, 0x0badf00d01020304);
4423 assert_eq!(outgoing_cltv_value, 0xffffffff);
4424 } else { panic!(); }
4428 fn encoding_final_onion_hop_data_with_trampoline_packet() {
4429 let secp_ctx = Secp256k1::new();
4430 let (_private_key, public_key) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
4432 let compressed_public_key = public_key.serialize();
4433 assert_eq!(compressed_public_key.len(), 33);
4435 let trampoline_packet = TrampolineOnionPacket {
4438 hop_data: vec![1; 650], // this should be the standard encoded length
4441 let encoded_trampoline_packet = trampoline_packet.encode();
4442 assert_eq!(encoded_trampoline_packet.len(), 716);
4444 let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
4445 multipath_trampoline_data: None,
4446 amt_to_forward: 0x0badf00d01020304,
4447 outgoing_cltv_value: 0xffffffff,
4450 let encoded_payload = msg.encode();
4452 let trampoline_type_bytes = &encoded_payload[19..=19];
4453 let mut trampoline_type_cursor = Cursor::new(trampoline_type_bytes);
4454 let trampoline_type_big_size: BigSize = Readable::read(&mut trampoline_type_cursor).unwrap();
4455 assert_eq!(trampoline_type_big_size.0, 20);
4457 let trampoline_length_bytes = &encoded_payload[20..=22];
4458 let mut trampoline_length_cursor = Cursor::new(trampoline_length_bytes);
4459 let trampoline_length_big_size: BigSize = Readable::read(&mut trampoline_length_cursor).unwrap();
4460 assert_eq!(trampoline_length_big_size.0, encoded_trampoline_packet.len() as u64);
4464 fn encoding_final_onion_hop_data_with_eclair_trampoline_packet() {
4465 let public_key = PublicKey::from_slice(&<Vec<u8>>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()).unwrap();
4466 let hop_data = <Vec<u8>>::from_hex("cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4c").unwrap();
4467 let hmac_vector = <Vec<u8>>::from_hex("bb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4468 let mut hmac = [0; 32];
4469 hmac.copy_from_slice(&hmac_vector);
4471 let compressed_public_key = public_key.serialize();
4472 assert_eq!(compressed_public_key.len(), 33);
4474 let trampoline_packet = TrampolineOnionPacket {
4480 let encoded_trampoline_packet = trampoline_packet.encode();
4481 let expected_eclair_trampoline_packet = <Vec<u8>>::from_hex("0002eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619cff34152f3a36e52ca94e74927203a560392b9cc7ce3c45809c6be52166c24a595716880f95f178bf5b30ca63141f74db6e92795c6130877cfdac3d4bd3087ee73c65d627ddd709112a848cc99e303f3706509aa43ba7c8a88cba175fccf9a8f5016ef06d3b935dbb15196d7ce16dc1a7157845566901d7b2197e52cab4ce487014b14816e5805f9fcacb4f8f88b8ff176f1b94f6ce6b00bc43221130c17d20ef629db7c5f7eafaa166578c720619561dd14b3277db557ec7dcdb793771aef0f2f667cfdbeae3ac8d331c5994779dffb31e5fc0dbdedc0c592ca6d21c18e47fe3528d6975c19517d7e2ea8c5391cf17d0fe30c80913ed887234ccb48808f7ef9425bcd815c3b586210979e3bb286ef2851bf9ce04e28c40a203df98fd648d2f1936fd2f1def0e77eecb277229b4b682322371c0a1dbfcd723a991993df8cc1f2696b84b055b40a1792a29f710295a18fbd351b0f3ff34cd13941131b8278ba79303c89117120eea691738a9954908195143b039dbeed98f26a92585f3d15cf742c953799d3272e0545e9b744be9d3b4cbb079bfc4b35190eee9f59a1d7b41ba2f773179f322dafb4b1af900c289ebd6c").unwrap();
4482 assert_eq!(encoded_trampoline_packet, expected_eclair_trampoline_packet);
4486 fn query_channel_range_end_blocknum() {
4487 let tests: Vec<(u32, u32, u32)> = vec![
4488 (10000, 1500, 11500),
4489 (0, 0xffffffff, 0xffffffff),
4490 (1, 0xffffffff, 0xffffffff),
4493 for (first_blocknum, number_of_blocks, expected) in tests.into_iter() {
4494 let sut = msgs::QueryChannelRange {
4495 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4499 assert_eq!(sut.end_blocknum(), expected);
4504 fn encoding_query_channel_range() {
4505 let mut query_channel_range = msgs::QueryChannelRange {
4506 chain_hash: ChainHash::using_genesis_block(Network::Regtest),
4507 first_blocknum: 100000,
4508 number_of_blocks: 1500,
4510 let encoded_value = query_channel_range.encode();
4511 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000186a0000005dc").unwrap();
4512 assert_eq!(encoded_value, target_value);
4514 query_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4515 assert_eq!(query_channel_range.first_blocknum, 100000);
4516 assert_eq!(query_channel_range.number_of_blocks, 1500);
4520 fn encoding_reply_channel_range() {
4521 do_encoding_reply_channel_range(0);
4522 do_encoding_reply_channel_range(1);
4525 fn do_encoding_reply_channel_range(encoding_type: u8) {
4526 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f000b8a06000005dc01").unwrap();
4527 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4528 let mut reply_channel_range = msgs::ReplyChannelRange {
4529 chain_hash: expected_chain_hash,
4530 first_blocknum: 756230,
4531 number_of_blocks: 1500,
4532 sync_complete: true,
4533 short_channel_ids: vec![0x000000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4536 if encoding_type == 0 {
4537 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4538 let encoded_value = reply_channel_range.encode();
4539 assert_eq!(encoded_value, target_value);
4541 reply_channel_range = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4542 assert_eq!(reply_channel_range.chain_hash, expected_chain_hash);
4543 assert_eq!(reply_channel_range.first_blocknum, 756230);
4544 assert_eq!(reply_channel_range.number_of_blocks, 1500);
4545 assert_eq!(reply_channel_range.sync_complete, true);
4546 assert_eq!(reply_channel_range.short_channel_ids[0], 0x000000000000008e);
4547 assert_eq!(reply_channel_range.short_channel_ids[1], 0x0000000000003c69);
4548 assert_eq!(reply_channel_range.short_channel_ids[2], 0x000000000045a6c4);
4550 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4551 let result: Result<msgs::ReplyChannelRange, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4552 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4557 fn encoding_query_short_channel_ids() {
4558 do_encoding_query_short_channel_ids(0);
4559 do_encoding_query_short_channel_ids(1);
4562 fn do_encoding_query_short_channel_ids(encoding_type: u8) {
4563 let mut target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f").unwrap();
4564 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4565 let mut query_short_channel_ids = msgs::QueryShortChannelIds {
4566 chain_hash: expected_chain_hash,
4567 short_channel_ids: vec![0x0000000000008e, 0x0000000000003c69, 0x000000000045a6c4],
4570 if encoding_type == 0 {
4571 target_value.append(&mut <Vec<u8>>::from_hex("001900000000000000008e0000000000003c69000000000045a6c4").unwrap());
4572 let encoded_value = query_short_channel_ids.encode();
4573 assert_eq!(encoded_value, target_value);
4575 query_short_channel_ids = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4576 assert_eq!(query_short_channel_ids.chain_hash, expected_chain_hash);
4577 assert_eq!(query_short_channel_ids.short_channel_ids[0], 0x000000000000008e);
4578 assert_eq!(query_short_channel_ids.short_channel_ids[1], 0x0000000000003c69);
4579 assert_eq!(query_short_channel_ids.short_channel_ids[2], 0x000000000045a6c4);
4581 target_value.append(&mut <Vec<u8>>::from_hex("001601789c636000833e08659309a65878be010010a9023a").unwrap());
4582 let result: Result<msgs::QueryShortChannelIds, msgs::DecodeError> = Readable::read(&mut Cursor::new(&target_value[..]));
4583 assert!(result.is_err(), "Expected decode failure with unsupported zlib encoding");
4588 fn encoding_reply_short_channel_ids_end() {
4589 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4590 let mut reply_short_channel_ids_end = msgs::ReplyShortChannelIdsEnd {
4591 chain_hash: expected_chain_hash,
4592 full_information: true,
4594 let encoded_value = reply_short_channel_ids_end.encode();
4595 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f01").unwrap();
4596 assert_eq!(encoded_value, target_value);
4598 reply_short_channel_ids_end = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4599 assert_eq!(reply_short_channel_ids_end.chain_hash, expected_chain_hash);
4600 assert_eq!(reply_short_channel_ids_end.full_information, true);
4604 fn encoding_gossip_timestamp_filter(){
4605 let expected_chain_hash = ChainHash::using_genesis_block(Network::Regtest);
4606 let mut gossip_timestamp_filter = msgs::GossipTimestampFilter {
4607 chain_hash: expected_chain_hash,
4608 first_timestamp: 1590000000,
4609 timestamp_range: 0xffff_ffff,
4611 let encoded_value = gossip_timestamp_filter.encode();
4612 let target_value = <Vec<u8>>::from_hex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f5ec57980ffffffff").unwrap();
4613 assert_eq!(encoded_value, target_value);
4615 gossip_timestamp_filter = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
4616 assert_eq!(gossip_timestamp_filter.chain_hash, expected_chain_hash);
4617 assert_eq!(gossip_timestamp_filter.first_timestamp, 1590000000);
4618 assert_eq!(gossip_timestamp_filter.timestamp_range, 0xffff_ffff);
4622 fn decode_onion_hop_data_len_as_bigsize() {
4623 // Tests that we can decode an onion payload that is >253 bytes.
4624 // Previously, receiving a payload of this size could've caused us to fail to decode a valid
4625 // payload, because we were decoding the length (a BigSize, big-endian) as a VarInt
4628 // Encode a test onion payload with a big custom TLV such that it's >253 bytes, forcing the
4629 // payload length to be encoded over multiple bytes rather than a single u8.
4630 let big_payload = encode_big_payload().unwrap();
4631 let mut rd = Cursor::new(&big_payload[..]);
4633 let node_signer = test_utils::TestKeysInterface::new(&[42; 32], Network::Testnet);
4634 <msgs::InboundOnionPayload as ReadableArgs<(Option<PublicKey>, &&test_utils::TestKeysInterface)>>
4635 ::read(&mut rd, (None, &&node_signer)).unwrap();
4637 // see above test, needs to be a separate method for use of the serialization macros.
4638 fn encode_big_payload() -> Result<Vec<u8>, io::Error> {
4639 use crate::util::ser::HighZeroBytesDroppedBigSize;
4640 let payload = msgs::OutboundOnionPayload::Forward {
4641 short_channel_id: 0xdeadbeef1bad1dea,
4642 amt_to_forward: 1000,
4643 outgoing_cltv_value: 0xffffffff,
4645 let mut encoded_payload = Vec::new();
4646 let test_bytes = vec![42u8; 1000];
4647 if let msgs::OutboundOnionPayload::Forward { short_channel_id, amt_to_forward, outgoing_cltv_value } = payload {
4648 _encode_varint_length_prefixed_tlv!(&mut encoded_payload, {
4649 (1, test_bytes, required_vec),
4650 (2, HighZeroBytesDroppedBigSize(amt_to_forward), required),
4651 (4, HighZeroBytesDroppedBigSize(outgoing_cltv_value), required),
4652 (6, short_channel_id, required)
4659 #[cfg(feature = "std")]
4660 fn test_socket_address_from_str() {
4661 let tcpip_v4 = SocketAddress::TcpIpV4 {
4662 addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
4665 assert_eq!(tcpip_v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
4666 assert_eq!(tcpip_v4, SocketAddress::from_str(&tcpip_v4.to_string()).unwrap());
4668 let tcpip_v6 = SocketAddress::TcpIpV6 {
4669 addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
4672 assert_eq!(tcpip_v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
4673 assert_eq!(tcpip_v6, SocketAddress::from_str(&tcpip_v6.to_string()).unwrap());
4675 let hostname = SocketAddress::Hostname {
4676 hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
4679 assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
4680 assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
4682 let onion_v2 = SocketAddress::OnionV2 ([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7],);
4683 assert_eq!("OnionV2([40, 4, 64, 185, 202, 19, 162, 75, 90, 200, 38, 7])", &onion_v2.to_string());
4684 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("FACEBOOKCOREWWWI.onion:9735"));
4686 let onion_v3 = SocketAddress::OnionV3 {
4687 ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
4688 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
4693 assert_eq!(onion_v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
4694 assert_eq!(onion_v3, SocketAddress::from_str(&onion_v3.to_string()).unwrap());
4696 assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
4697 assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
4698 assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());
4699 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:9735:94").is_err());
4700 assert!(SocketAddress::from_str("wrong$%#.com:1234").is_err());
4701 assert_eq!(Err(SocketAddressParseError::InvalidPort), SocketAddress::from_str("example.com:wrong"));
4702 assert!("localhost".parse::<SocketAddress>().is_err());
4703 assert!("localhost:invalid-port".parse::<SocketAddress>().is_err());
4704 assert!( "invalid-onion-v3-hostname.onion:8080".parse::<SocketAddress>().is_err());
4705 assert!("b32.example.onion:invalid-port".parse::<SocketAddress>().is_err());
4706 assert!("invalid-address".parse::<SocketAddress>().is_err());
4707 assert!(SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion.onion:1234").is_err());
4711 #[cfg(feature = "std")]
4712 fn test_socket_address_to_socket_addrs() {
4713 assert_eq!(SocketAddress::TcpIpV4 {addr:[0u8; 4], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4714 SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(0,0,0,0), 1337)));
4715 assert_eq!(SocketAddress::TcpIpV6 {addr:[0u8; 16], port: 1337,}.to_socket_addrs().unwrap().next().unwrap(),
4716 SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::from([0u8; 16]), 1337, 0, 0)));
4717 assert_eq!(SocketAddress::Hostname { hostname: Hostname::try_from("0.0.0.0".to_string()).unwrap(), port: 0 }
4718 .to_socket_addrs().unwrap().next().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from([0u8; 4]),0)));
4719 assert!(SocketAddress::OnionV2([0u8; 12]).to_socket_addrs().is_err());
4720 assert!(SocketAddress::OnionV3{ ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102,
4721 182, 107, 4, 105, 247, 246, 85, 111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31,
4725 port: 1234 }.to_socket_addrs().is_err());